L'Altruiste : Le guide des langages Web

1 / La logique

1.1 / Les tables de vérité

1.2 / Correspondance binaires/décimales

1.3 / Méthode de conversion binaires/décimaux

1.4 / Méthode de conversion décimaux/binaires

Pour trouver un nombre binaire à partir d'un nombre décimal, il faut successivement diviser par deux le nombre décimal puis les quotients résultants jusqu'à obtenir un zéro ou un un.

Puis il suffit de lire le nombre binaire en prenant en compte le dernier quotient (1 ou 0) de la division puis effectuer une lecture du bas en haut pour les restes.

1.5 / Lois

Parfois, il peut être très utile de simplifier des expressions booléennes de sorte à devenir plus compréhensibles et plus maniables dans un programme.

Exp1 OR (Exp2 AND Exp3) = (Exp1 OR Exp2) AND (Exp1 OR Exp3)
Exp1 AND (Exp2 OR Exp3) = (Exp1 AND Exp2) OR (Exp1 AND Exp3)

non(Exp1 AND Exp2) = NOT Exp1 OR NOT Exp2
non(Exp1 OR Exp2) = NOT Exp1 AND NOT Exp2

non(non Exp1) = Exp1

Exp1 OR NOT Exp1 = vrai

Exp1 AND NOT Exp1 = faux

Exp1 AND Exp1 = Exp1
Exp1 AND vrai = Exp1
Exp1 AND faux = faux
Exp1 AND (Exp1 OR Exp2) = Exp1

Exp1 OR Exp1 = Exp1
Exp1 OR vrai = vrai
Exp1 OR faux = Exp1
Exp1 OR (Exp1 AND Exp2) = Exp1

2 / Les nombres

2.1 / Représentation binaire des nombres décimaux

Les nombres décimaux possèdent une représentation binaire standardisée pour les valeurs de précision simple (32 bits) et double (64 bits) par ANSI/IEEE Standard 754-1985.

La représentation binaire des nombres à virgules flottantes de précision simple requiert un mot de 32 bits, lequel est composé d'un bit de signe S, de 8 bits pour l'exposant E et de 23 bits pour la fraction décimale.

S EEEEEEEE FFFFFFFFFFFFFFFFFFFFFFF
0 1EEEEEEE8 9FFFFFFFFFFFFFFFFFFFFFFFF31

La valeur exprimée par cette représentation binaire est déterminée selon certaines conditions applicables aux parties E, F et S.

La représentation binaire des nombres à virgules flottantes de précision simple requiert un mot de 64 bits, lequel est composé d'un bit de signe S, de 11 bits pour l'exposant E et de 52 bits pour la fraction décimale.

S EEEEEEEEEEE 
  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
0 1EEEEEEEEEE11 
  12FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF64

La valeur exprimée par cette représentation binaire est déterminée selon certaines conditions applicables aux parties E, F et S

2.2 / Représentation binaire des nombres négatifs

Les nombres négatifs possèdent une représentation binaire spécifique afin de les distinguer des nombres positifs.

En fait, les nombres binaires négatifs sont appelés nombres signés car ils possèdent une longueur fixe et à leur extrême gauche un bit égal à 1.

1000 1001 // est égal à -9
0000 1001 // est égal à +9

En pratique, cette représentation n'est guère utilisable puisque l'ordinateur n'est pas capable de gérer correctement les opérations arithmétiques dans ces conditions.

   0000 1110 // est égal à 14
+ 1000 1001 // est égal à -9
   1001 0111 // est égal à -23

   0000 0101 // devrait être égal à 5

Devant ce dysfonctionnement patent, il est nécessaire de représenter différemment les nombres binaires négatifs.

0000 1001 // est égal à 9

1111 1111 // complément à 1
0000 1001
1111 0110
0000 0001 // ajout de 1
1111 0111 // est égal à -9

1111 0111
0000 1001 // ajout de 9
0000 0000 //est bien égal à 0

En premier lieu, le nombre est complémenté à 1 puis la valeur binaire 1 est ajoutée pour donner finalement une représentation binaire exploitable du nombre négatif correspondant.

   0000 1110 // est égal à 14
+ 1111 0111 // est égal à -9
   0000 0101 // est égal à 5

3 / Les types d'encodage

Le tableau ci-dessous fournit la liste des différents types d'encodage et leur nom utilisable sur Internet et leur disponibilité sur Mac OS.

Les langages
Type d'encodage	Nom commun sur Internet	Information
Les langages universels
Unicode 2.0 (16 bit)	UTF-16
Unicode 2.0 UTF-8	UTF-8
Unicode 2.0 UTF-7	UTF-7
Unicode 1.1 (16-bit)	UNICODE 1-1
Unicode 1.1 UTF-8	UNICODE-1-1-UTF-8
Unicode 1.1 UTF-7	UNICODE-1-1-UTF-7
Les langages d'Europe de l'Ouest
ASCII	US-ASCII
ISO 8859-1 (Latin-1)	ISO-8859-1, latin1
ISO 8859-3 (Latin 3)	ISO-8859-3 , latin3
ISO-8859-15 (Latin 9)	ISO-8859-15, latin9	Latin-1 avec le signe EURO et les lettres cp1252
CP 1252 (Windows Latin-1)	windows-1252, cp1252	ISO 8859-1, plus des ajouts dans la zone C1
CP 437 (DOS Latin-US)	cp437
CP 850 (DOS Latin-1)	cp850
Mac OS Roman	mac, macintosh, x-mac-roman
Mac OS Icelandic	x-mac-icelandic	Fondé sur Mac OS Roman
Mac OS Latin-1, Mac OS Mail	x-mac-latin1 (communément assimilé à ISO-8859-1)	Mac OS Roman permuté pour s'aligner à 8859-1
NextStep Latin
CP 037 (EBCDIC-US)	cp037	ISO 8859-1 avec différentes dispositions
Les langages d'Europe centrale
ISO 8859-2 (Latin-2)	ISO-8859-2, latin2
ISO 8859-4 (Latin-4)	ISO-8859-4, latin4
CP 1250 (Windows Latin-2)	windows-1250, cp1250	Partiellement 8859-2, plus des ajouts de C1
CP 1257 (Windows Baltique)	windows-1257,cp1257
Mac OS Central Roman européen	x-mac-centraleurroman
Mac OS Croatian	x-mac-croatian	Fondé sur Mac OS Roman
Mac OS Romanian	x-mac-romanian	Fondé sur Mac OS Roman
Les langages Arabes
ISO 8859-6 (Latin/Arabe)	ISO-8859-6, arabe
CP 1256 (Windows Arabe)	windows-1256, cp1256	Partiellement basé sur 8859-6, plus des ajouts de C1
CP 864 (DOS Arabic)	cp864	Encode les formes de présentation Arabe
Mac OS Arabic	x-mac-arabic
Mac OS Farsi	x-mac-farsi
Les langages Chinois
GB 2312-80
EUC-CN	GB2312, X-EUC-CN	ASCII et GB 2312-80 (8-bit)
CP 936 (DOS et Windows simplifiés)		Similaire à GBK
Mac OS Chinois simplifié		Fondé sur EUC-CN
ISO 2022-CN ("GB")	ISO-2022-CN	ASCII et GB 2312-80 (7-bit) (voir RFC 1922)
HZ	HZ-GB-2312	ASCII et GB 2312-80 (7-bit) (voir RFC 1842);
GBK (extended GB)		EUC-CN et Unihan (8-bit)
CNS 11643 plane 1	x-cns11643-1
CNS 11643 plane 2	x-cns11643-2
EUC-TW	X-EUC-TW	ASCII et CNS 11643-1992 (8-bit)
Big-5	Big5	(8-bit)
CP 950 (DOS et Windows traditionnel)		Fondé sur Big-5
Mac OS (Chinois traditionnel)		Fondé sur Big-5
CCCII
EACC
Les langages cyrilliques
ISO 8859-5 (Latin/Cyrillique)	ISO-8859-5, cyrillique
KOI8-R	KOI8-R	Voir RFC 1489
CP 1251 (Windows Cyrillique)	windows-1251, cp1251	non fondé sur ISO 8859-5
CP 866 (DOS Russe)	cp866
Mac OS Cyrillic	x-mac-cyrillic
Mac OS Ukrainian	x-mac-ukrainian	Mac OS Cyrillic avec deux remplacements
Les langages Grecs
ISO 8859-7	ISO-8859-7, grec
ISO 5428	ISO_5428:1980
CP 1253 (Windows Grec)	windows-1253, cp1253	Quasiment fondé sur 8859-7, plus des ajouts de C1
Mac OS Greek	x-mac-greek
Greek CCITT	greek-ccitt
Les langages Hébraïques
ISO 8859-8 (Latin/Hébreux)	ISO-8859-8, hébreux
CP 1255 (Windows Hébreux)	windows-1255, cp1255	Principalement basé sur 8859-8, plus des ajouts C1
Mac OS Hebrew (2 variantes)	x-mac-hebrew
Les langages Indiens
ISCII-91		Encodages parallèles pour tous les scripts indiens
Mac OS Gujarati
Mac OS Devanagari
Mac OS Gurmukhi
Les langages Japonais
JIS X0208
JIS X0212
EUC-JP	EUC-JP, X-EUC-JP	JIS 201, JIS 208 et JIS 212 (8-bit)
ISO 2022-JP ("JIS")	ISO-2022-JP	JIS 201, JIS 208 et JIS 212 (7-bit); RFC 1468
Shift-JIS	Shift_JIS, x-sjis, x-shift-jis	JIS 201 et JIS 208 (8-bit)
CP 932 (DOS et Windows)		Fondé sur Shift-JIS
Mac OS Japanese		Fondé sur Shift-JIS
Les langages coréens
KSC 5601-1987
EUC-KR	EUC-KR	ASCII et KSC 5601-87 (8-bit); RFC 1557
CP 949 (DOS et Windows)		Code Hangul unifié : EUC-KR et Johab
Mac OS Korean		Fondé sur EUC-KR
ISO 2022-KR ("KSC")	ISO-2022-KR	ASCII et KSC 5601-87 (7-bit): RFC 1557
KSC 5700
Les langages Thaïs
TIS 620-2533
CP 874 (DOS et Windows)	cp874	Fondé sur TIS 620-2533
Mac OS Thai	x-mac-thai	Fondé sur TIS 620-2533
Les langages Turcs
ISO 8859-9 (Latin-5)	ISO-8859, latin5
ISO 8859-3 (Latin-3)	ISO-8859-3
CP 1254 (Windows Latin-5)	windows-1254, cp1254
Mac OS Turkish	x-mac-turkish	Fondé sur Mac OS Roman
Les langages Vietnamiens
VISCII	VISCII	RFC 1456
TCVN-n
CP 1258 (Windows Vietnamien)	windows-1258, cp1258
Les langages symboliques
Adobe Symbol	Adobe-Symbol-Encoding
Mac OS Symbol	x-mac-symbol	Fondé sur Adobe Symbol
Mac OS dingbats	x-mac-dingbats	Fondé sur Adobe Zapf Dingbats

4 / Le code ISO-8859-1

5 / Le code ISO-639

6 / Les identificateurs locaux

7 / Les identifcateurs d'application windows

Les identificateurs CLSID (CLasse IDentifier) sont utilisés pour appeler des applications Microsoft Windows dans des prorammes écrits dans divers langages tels que l'ASP, le PHP ou d'autres.

La liste des identificateurs CLSID présents sur un serveur se trouvent dans le fichier regedit.exe, dans le répertoire HKEY_CLASSES_ROOT classés par application.

Une liste complète classée par identificateurs, se trouve également sous le dossier CLSID du même répertoire.

8 / Les pages de code

Les pages de code (CodePages) standards supportés par Windows sont citées dans le tableau ci-dessous avec le ou les jeux de caractères et les langues correspondants.

9 / Les entêtes MIME

Les entêtes des messages Internet sont normalisés par les RFC (Requests For Comments) 822, 2045, 2046, 2047, 2048, 2049 relatif au extensions polyvalentes des messages internet (MIME : Multipurpose Internet Mail Extensions).

From: Jacques Crenca <j_c@domaine.net>
To: Jean Jean <jean2@dom.com>
Reply-To: "Jacques Crenca" <message@domaine.net>
Subject: Re: Bonjour
Date: Mon, 25 Mar 2002 09:18:52 -0200
Message-ID: <1255388558@domaine.net>
In-Reply-To: <20012500365485@domaine.net>
References: <20012500365485@domaine.net>
MIME-Version: 1.0
Content-Type: text/plain; charset="iso-8859-1"
Content-Transfer-Encoding: 7bit

Le second exemple fait appel à un contenu mixte en assemblant deux messages à un courrier électronique.

From: Jacques Crenca <j_c@domaine.net>
To: Jean Jean <jean2@dom.com>
Bcc: Direction <pdg@domaine.net>
Date: Mon, 25 Mar 2002 09:18:52 -0200
Subject: Critique du rapport n°10254365
MIME-Version: 1.0
Message-ID: <1255388558@domaine.net>
Content-Type: multipart/mixed; boundary="/-----10254365-----/"
Content-ID: <id53464631236546@site.com>

--/-----10254365-----/

Première partie du message...

--/-----10254365-----/
Content-Type: multipart/digest; boundary="/-----suite du courrier-----/"

--/-----suite du courrier-----/

From: Emile Ntamack <emile@domaine.net>
Date: Mon, 25 Mar 2002 09:18:52 -0200
Subject: Remarque d'un interlocuteur

Seconde partie du message...

--/-----suite du courrier-----/

From: Jean-Pierre Rives <jp.rives@domaine.net>
Date: Mon, 25 Mar 2002 09:18:52 -0200
Subject: Remarque d'une autre personne

Troisième partie du message...

--/-----suite du courrier-----/

--/-----10254365-----/--

Un message l'attribut content-type égal à multipart/alternative possède plusieurs parties proposant un contenu identique mais accessible par différent mécanisme. Dans l'exemple ci-dessous, un contenu spécial est proposé selon trois méthodes alternatives.

From: Jacques Crenca <j_c@domaine.net>
To: Jean Jean <jean2@dom.com>
Date: Mon, 25 Mar 2002 09:18:52 -0200
Subject: Sujet du courrier
MIME-Version: 1.0
Message-ID: <123486709786768@domaine.net>
Content-Type: multipart/alternative; boundary=216878686686346458
Content-ID: <id53464631236546@site.com>

--216878686686346458
Content-Type: message/external-body; name="fichier.ps";
            site="laltruiste.com"; mode="image";
            access-type=ANON-FTP; directory="fichier/rapport";
            expiration="Fri, 14 Jun 1991 19:13:14 -0400 (EDT)"

Content-type: application/postscript
Content-ID: <id216878686686346458@laltruiste.com>

--216878686686346458
Content-Type: message/external-body; access-type=local-file;
            name="/doc/sujet/fichier.ps";
            site="laltruiste.com";
            expiration="Fri, 14 Jun 1991 19:13:14 -0400 (EDT)"

Content-type: application/postscript
Content-ID: <id216878686686346458@laltruiste.com>

--216878686686346458
Content-Type: message/external-body;
            access-type=mail-server
            server="laltruiste@server.net";
            expiration="Fri, 14 Jun 1991 19:13:14 -0400 (EDT)"

Content-type: application/postscript
Content-ID: <id216878686686346458@laltruiste.com>

get fichier.rtf

--216878686686346458--

10 / Les modes d'accès aux fichiers et répertoires

Il existe différents modes permettant d'affecter des droits d'accès aux fichiers ou aux répertoires.

Les droits d'accès peuvent se faire en lecture (r : read), en écriture (w : write) et en exécution (x : execute) ou bien en une quelconque combinaison de ces trois derniers.

droits d'accès :  rwx   r-x   r--  égale à  7   5   4

Les permissions peuvent être accordées différemment à trois types d'utilisateurs : les propriétaires, les utilisateurs faisant partis d'un groupe et les tous les autres.

Chaque type est représenté par un nombre octal résultant d'une addition des valeurs de bit provenant de chacun de leurs attributs.

11 / Les algorithmes

11.1 / Notions

• entier : -limite_système, -124, -45, -2, 0, 14, 78, 325, limite_système.
• réel : -limite_système, -43E+541, -15.62, -0.08502, 0.0, 25.36, 9778.03, 759E-95, limite_système.
• caractère : caractères Unicode : [a-zA-Z0-9] et n'importe quels caractères accentués (é, à, ö, etc..) ou spéciaux ($, #, ?, etc..).
• chaîne : n'importe quelle suite de caractères "\tUne brebis égarée dans la forêt\n".
• booléen : vrai (true : 1) ou faux (false : 0)
• énuméré : représente une collection de constantes énumérées possibles pour une variable.

  # Création #
     type mois : chaîne : ("janvier","février","mars",
                                      "avril","mai","juin",
                                      "juillet","août","septembre",
                                      "octobre","novembre","décembre",);
     type num_mois : entier : (1,2,3,4,5,6,7,8,9,10,11,12);

• intervalle : représente un intervalle de valeur possible pour une variable.

  # Création #
     type num_mois : entier : 1..12;
     type alphabet : caractère : 'A'..'Z';
     type été : mois : "juillet".."septembre";

# Création #
var identificateur : type;

var identificateur : type := valeur_initialisatrice;

var i : entier;

var j : entier := 0;

# Affectation #
variable := valeur;

phrase := "Une chaîne de caractères...";

# Création #
const IDENTIFICATEUR : type := valeur_constante;

const PI : réel := 3.14;

variable : type := expression;

nom : chaîne := "Jean-Pierre" + " " + "RODERER";

surface : réel := PI * Rayon ** 2;

reussir : booléen := vrai et faux ou vrai et non faux;

1. + (unaire), - (unaire),
2. ** (puissance),
3. *, /, div (division d'entier), modulo,
4. + (binaire), - (binaire).

var resultat : réel := 4 * -5 / -2 + 20 - 5 ** 3 / 10;
resultat := ((((4 * (-5)) / (-2)) + 20) - ((5 ** 3) / 10));
resultat := (((-20 / -2) + 20) - (125 / 10));
resultat := 30 - 12.5;
resultat := 17.5;

1. non
2. et
3. ou

non Exp1 et Exp2 ou Exp3 et non Exp4 ou Exp5
((((non Exp1) et Exp2) ou (Exp3 et (non Exp4))) ou Exp5)

• = : égalité,
• <> : différence,
• >= : supérieur ou égal,
• <= : inférieur ou égal,
• > : supérieur,
• < : inférieur.

variable : booléen := expression_comparative;

réussite : booléen := i < 10;

réussite : booléen := (i < 10) et (j <> 0);

L'opérateur de concaténation
var resultat : chaîne := chaîne + chaîne2 + caractère + ... + chaîneN;

resultat : chaîne := "Bonjour " + 'à' + " tous";
resultat := "Bonjour à tous";

Les opérateurs sont associatifs à gauche hormis l'opérateur de puissance **.

La mise entre paranthèses d'une expression contraint à une évaluation prioritaire de cette dernière.

# Création #
proc identificateur[([val param_val: type,...,param_valN: type][;
                      valres param_val_res: type,...,param_val_resN: type][;
                      res param_res: type,...,param_résN: type])];
 [variable_locale : type := valeur;
  ...
  variable_localeN : type := valeur;]

  début
  Instructions...
fproc

proc compteur;
  var cpt : entier := 0;
      i : entier;
  début
  pour i := 0 jusqu'à 10 faire
      cpt := cpt + 1;
      écrire(i, " ", cpt);
  fpour;
fproc

proc tri(val nb : entier; valres un_tableau : 
                                   tableau[1..MAX]; res reussie : boolean)

# Création #
fonction identificateur([paramètre: type,...,paramètreN: type]): type;
 [variable_locale : type := valeur;
  ...
  variable_localeN : type := valeur;]

  début
  Instructions...
  résultat valeur;
ffonction

fonction aire_cercle(diamètre : réel) : réel;
  var PI : réel := 3.14;

  début
  aire : réel := (PI * (diamètre ** 2)) / 2;
  resultat aire;
ffonction

# Appel de fonction #
variable : type_fonction := 
                      identificateur_fonction([argument,..., argumentN]);

surface : réel := aire_cercle(15);

# Création #
type identificateur : struct
  variable : type,
  ...,
  variableN : type
  fstruct;
...
  identificateurN struct
  variable : type,
  ...,
  variableN : type
  fstruct;

type personnel : struct
  identifiant : entier,
  nom, prénom : chaîne,
  date_naissance : chaîne(10),
  adresse : chaîne,
  code_postal : entier,
  ville : chaîne,
  pays : chaîne,
  telephone : entier
  fstruct;

  société : struct
  num_siret : entier,
  nom : chaîne,
  dirigeant : personnel,
  nb_personnel : entier
  fstruct;

# Déclaration de variable structure #
var nom_variable : identificateur_structure;

var dirigeant : personnel;

var entreprise : société;

# Affectation #
identificateur_structure.nom_champs := valeur;

entreprise.dirigeant.nom := "MAGNARD";

entreprise.nom := "ALAPAGE";

entreprise.num_siret := 41426553800010;

# Lecture #
variable : type_champs := identificateur_structure.nom_champs;

pdg : chaîne := entreprise.dirigeant.nom 
             + " " + entreprise.dirigeant.prénom

# Utilisation avec avec #
avec identificateur_structure faire
  nom_champs := valeur;
  variable : type_champs := nom_champs;
favec;

avec entreprise faire
  nom := "ALAPAGE";
  dirigeant.pays := "France";

  avec dirigeant faire
  nom := "MAGNARD";
  prénom := "Patrice";
  favec;
favec;

# Création #
identificateur : tableau[début..fin{, ..., débutN..finN}] de type

un_tableau : tableau[1..10,1..10] de entier;
#Création d'un tableau bidimensionnel de 100 cellules#
# Affectation #
tableau[index{, indexN}] := valeur;

un_tableau[1,1] := 12;

# Lecture #
tableau[index{, indexN}] := valeur;

type_tableau : variable := un_tableau[1,1] := 12;

écrire(valeur);

écrire("Notions d'algorithme");

si expression_booléenne
alors instructions...;
[sinon si seconde_expression_booléenne
alors instructions...;]
[...]
[sinon si Nième_expression_booléenne
alors instructions...;]
[sinon Instructions...;]
fsi

si variable < 10 alors
  écrire("La variable est supérieure à 10 :", variable);
sinon si variable > 10 alors
  écrire("La variable est inférieure à 10 :", variable););
sinon si variable = 10 alors
  écrire("La variable est égale à 10 :", variable););
fsi

choix 
  expression_booléenne -> cas
  Instructions...;
  fcas
  ...
  expression_booléenneN -> cas
  Instructions...;
  fcas
fchoix;

choix
  mois = "janvier"
  ou mois = "février"
  ou mois = "mars" -> cas;
  écrire("Nous sommes dans la saison hivernale.");
  fcas
  mois = "avril"
  ou mois = "mai"
  ou mois = "juin" -> cas;
  écrire("Nous sommes dans la saison du printanière.");
  fcas
  mois = "juillet"
  ou mois = "août"
  ou mois = "septembre" -> cas;
  écrire("Nous sommes dans la saison estivale.");
  fcas
  mois = "octobre"
  ou mois = "novembre"
  ou mois = "décembre" -> cas;
  écrire("Nous sommes dans la saison automnale.");
  fcas
fchoix;

répéter
  Instructions...
jusqu'à expression_booléenne

i : entier := 0;
répéter
  écrire("Contenu cellule ", i, " : ", tableau[i], "\n");
  i := i + 1;
jusqu'à i >= tableau.longueur()

tant que expression_booléenne
  Instructions...
fin tant que

i : entier := 0;
tant que i < tableau.longueur()
  écrire("Contenu cellule ", i, " : ", tableau[i], "\n");
  i := i + 1;
fin tant que

pour expression_d'initialisation
[1(défaut) | pas expression_d'incrémentation]
jusqu'à expression_finale
faire
  Instructions...
fin pour

num : entier := 0;
pour i := 0 pas 2 jusqu'à 10 faire
  num := num + 1;
  écrire("Numéro de boucle et valeur de i : ", num, " et ", i);
fin pour

lire(variable);

lire(nom);

algorithme
  var nom, prénom : chaîne;
début
  écrire("Saisissez vos nom et prénom ",
                 "séparés par une virgule : ");
  lire(nom, prénom);
  écrire("Bienvenue dans ce programme ",
                  prénom, " ", nom);
fin

11.2 / Création

# Création #
algorithme
  déclaration des objets
début
  instructions...
fin

Une précondition représente les états initiaux possibles des objets énoncés dans un problème à résoudre par un algorithme.
Tandis qu'une postcondition représente les états finaux de ces mêmes objets.

P : prédicat_préconditionnel,
Q : prédicat_postconditionnel

# a et b sont des chaînes 
à comparer lexicographiquement #

P: a <> b,
Q: c = max(a, b)

# signifie que a et b sont strictement différents 
et qu'il faut écrire un algorithme pour déterminer 
le plus grand d'entre eux. #

(c = a et c <> b) ou (c = b et c <> a)

algorithme
var a, b, c : chaîne;

début
  si a > b alors
  c := a;
  sinon si b > a alors
  c := b;
  fsi;
fin

P: a >= b
Q: c = max(a, b)

algorithme
var a, b, c : chaîne;

(c = a et c >= b) ou (c = b et c < a)


début
  si a >= b alors
  c := a;
  sinon
  c := b;
  fsi;
fin

P: n > 2,
Q: factorielle = f(n)

(f = 1 et n <= 2) ou (f = x et n > 2)

fonction factorielle(n : entier) : entier;
  entier : i, f := 1;

début
  pour i := 2 jusqu'à n faire
  f = f * i;
  fpour

  resultat f;
ffonction

11.3 / Les fonctions prédéfinies

fonction longueur(val chaîne_source : chaîne) : entier;

fonction morceau(val var_chaîne : chaîne, 
                                 pos_début, pos_fin : entier) : chaîne;

fonction index(val chaîne_source, 
                          chaîne_recherchée : chaîne) : entier;

proc insérer(val chaîne_inseree : chaîne, position : entier, 
                    valres chaîne_source : chaîne);

proc effacer(val pos_début, pos_fin : entier, 
                   valres chaîne_source : chaîne);

# Exemples #
chaîne_source : chaîne := "Microsoft ajoutera un outil "
                                     + "XML à sa suite Office en 2003.";
taille : entier := longueur(chaîne_source);
taille := 58;

insérer("peut-être ", 19, chaîne_source);
chaîne_source : chaîne := "Microsoft ajoutera peut-être un outil "
                                    + "XML à sa suite Office en 2003.";

fonction compter_ligne(val rel : relation) : entier;

fonction énumérer_ligne(val rel : relation) : entier;

fonction énumération_terminée(val numéro_énumération : entier) 
                                                                                      : booléen;

proc fermer_énumération(val numéro_énumération : entier);

fonction ligne_suivante(val numéro_énumération : entier) : ligne;

proc ajouter_ligne(val rel : relation, ligne : t_ligne, 
                           res ok : booléen);

proc supprimer_ligne(val rel : relation, clé : t_clé, 
                            res ok: booléen);

proc modifier_ligne(val rel : relation, ligne : t_ligne, 
                         res ok booléen);

proc rechercher_ligne(val rel : relation, clé : t_clé, 
                          res ligne : t_ligne, trouvé : booléen);

# Exemples #
var num_lignes : entier := compter_ligne(PERSONNEL);

ajouter_ligne(PERSONNEL, "1032578 MOULET Isabelle", reussi);

rechercher_ligne(PERSONNEL, 1036412, enregistrement, existe);

algorithme
  type opération : (1, 2, 3);
  type tuple : struct
  ID : entier,
  NOM : chaîne,
  PRENOM : chaîne
  fstruct;

  var action : opération;
        tableau : relation;
        ligne : tuple;
        ident : entier;
        nom, prénom : chaîne;

  proc affichage(val rel : relation);
  var i : entier := 0;

  début
  i := énumérer_ligne(rel);
  écrire("\tID \tNom \tPrénom");
  tant que non(énumération_terminée(i))
      ligne := tuple_suivant(i);
      avec ligne faire
        écrire("\t", ID, "\t", NOM, "\t", PRENOM);
      favec;
  fin tant que;
  fin

  proc modification(rel : relation);
  var réussi : boolean;

  début
  choix
      action = 1 -> cas
        écrire("fournissez les données (ID, NOM, PRENOM) :");
        lire(ident, nom, prénom);
        avec ligne faire
        lire(ID, NOM, PRENOM);
        favec;
        ajouter_ligne(rel, ligne, réussi);
        si réussi alors écrire("Ajout réussi !");
        sinon écrire("Echec de l'ajout !");
        fsi
      fcas
      action = 2 -> cas
        écrire("fournissez la clé de l'enregistrement (ID) :");
        lire(ident);
        supprimer_ligne(rel, ident, réussi);
        si réussi alors écrire("Suppression réussie !");
        sinon écrire("Echec de la suppression !");
        fsi
      fcas
      action = 3 -> cas
        écrire("fournissez les données (ID, NOM, PRENOM) :");
        avec ligne faire
        lire(ID, NOM, PRENOM);
        favec;
        modifier_ligne(rel, ligne, réussi);
        si réussi alors écrire("Modification réussie !");
        sinon écrire("Echec de la modification !");
        fsi
      fcas
  fchoix
  fin

  proc recherche(val rel : relation)
  var réussi : boolean;

  début
  écrire("fournissez la clé de l'enregistrement (ID):");
  lire(ident);
  rechercher_ligne(rel, ident, ligne, reussi);
  si réussi alors
      écrire("La recherche a réussi :\n");
      écrire(ligne);
  sinon écrire("La recherche a échoué !");
  fsi
  fin

début
  tableau := PERSONNEL;
  écrire("1 - Ajout d'un enregistrement,\n",
         "2 - Modification du tableau,\n",
         "3 - Recherche d'un enregistrement.\",
         "choix : ");
  lire(action);
  choix
  action = 1 -> cas
      affichage(tableau);
  fcas
  action = 2 -> cas
      modification(tableau);
  fcas
  action = 3 -> cas
      recherche(tableau);
  fcas
  fchoix
fin

11.4 / Les types abstraits

Les types abstraits introduisent la notion de méthodologie objet dans les algorithmes.

Un type abstrait est constitué de plusieurs constantes, variables et méthodes (fonctions ou procédures) dont certaines constituent une interface par laquelle un objet pourra être manipulé sans pour autant connaître sa mise en oeuvre (ou implémentation).

# Création d'un type abstrait #
type abstrait : identificateur
  interface
  # Déclaration des méthodes #
  {fonction* | proc} nom_méthode([arguments]){: type*};
  ...
  {fonction* | proc} nom_méthodeN([arguments]){: type*};

  représentation
  # Déclaration des variables et constantes #
  {var | const} nom : type;
  ...
  {var | const} nomN : type;

  algorithmes
  # Définitions des méthodes #
  {fonction* | proc} nom_méthode([arguments]){: type*};
      ...
  début
      ...
  fin
  ...
  {fonction* | proc} nom_méthodeN([arguments]){: type*};
      ...
  début
      ...
  fin

ftypeabstrait

# Création d'un objet #
var identificateur_objet : identificateur_type_abstrait;

# Utilisation des méthodes #
identificateur_objet.nom_méthode([arguments]);

# Utilisation des variables et constantes # Une variable ou une constante déclarée dans représentation peut être accédé dans toutes les méthodes du type abstrait.
Les variables peuvent également être modifiées à partir du bloc d'instructions de ces mêmes méthodes.

# Exemple #
type abstrait : Calculatrice
  interface
  proc saisie(res valA, valB : réel, valOP : opération);
  proc calcul(val valA, valB : réel, valOP : opération, res resultat: réel);
  proc affichage(val valA, valB, resultat : réel, valOP : opération);

  représentation
  type opération : énumération : ('+','-','*','/');
  var valA, valB : réel, valOP : opération

  algorithmes
  proc saisie();
  début
      écrire("Entrez un calcul simple 
                     [Nombre, (+ | - | * | /), Nombre (ex.:10.2, *, 5)] :");
      lire(valA, valOP, valB);
  fproc

  proc calcul(res result: réel);
  début
      choix
        type_calcul = '+' -> cas
        result := addition(valA, valB);
        fcas
        type_calcul = '-' -> cas
        result := soustraction(valA, valB);
        fcas
        type_calcul = '*' -> cas
        result := multiplication(valA, valB);
        fcas
        type_calcul = '/' -> cas
        result := division(valA, valB);
        fcas
      fchoix
  fproc

  proc affichage(val result : réel);
  début
      écrire("Opération : ", valA, " ", valOP, " ", valB, " = ", result);
  fproc

  fonction addition(val a, b) : réel;
  début
      résultat (a + b);
  ffonction

  fonction soustraction(val a, b) : réel;
  début
      résultat (a - b);
  ffonction

  fonction multiplication(val a, b) : réel;
  début
      résultat (a * b);
  ffonction

  fonction division(val a, b) : réel;
  début
      résultat (a / b);
  ffonction
ftypeabstrait

algorithme
  var calc : Calculatrice;
         valeur_resultat : réel;
début
  calc.saisie();
  calc.calcul(valeur_resultat);
  calc.affichage(valeur_resultat);
fin

12 / La programmation orientée objet

La programmation a évolué selon plusieurs étapes successives, en passant de l'assembleur à des langages spécialisés tels que FORTRAN (1957) et COBOL (1959), puis aux langages procéduraux comme BASIC (1964), PASCAL (1968) et C (1973) et enfin vers des langages orientées objets à l'image du C++ (1983), Java (1995) et C# (2000).

Une des étapes principales fut la programmation structurée, appelée également procédurale ou impérative, dont le principe fondamental était la décmposition d'un programme en de multiples sous-programmes ou modules effectuant chacun une certaine action non élémentaire, et partant, permettant de décomplexifier une application de grande taille.

Les langages orientés objets sont une nouvelle méthode de programmation qui tend à se rapprocher de notre manière naturelle d'appréhender le monde. Les L.O.O. se sont surtout posé la question "Sur quoi porte le programme ?". En effet, un programme informatique comporte toujours des traitements, mais aussi et surtout des données. Si la programmation structurée s'intéresse aux traitements puis aux données, la conception objet s'intéresse d'abord aux données, auxquelles elle associe ensuite les traitements. L'expérience a montré que les données sont ce qu'il y a de plus stable dans la vie d'un programme, il est donc intéressant d'architecturer le programme autour de ces données.

La programmation orientée objet se différencie radicalement de celle fondée sur des procédures. La programmation procédurale (ou impérative) met en oeuvre des fonctionnalités écrites sous la forme d'une liste d'instructions à exécuter progressivement, soit les unes après les autres et éventuellement avec des appels de procédures ou de fonctions effectuant chacune une certaine action non élémentaire.

La programmation orientée objet (POO) est basée sur la représentation par des objets, des entités définies par l'étude du problème à réaliser.

La POO décompose un programme en de multiples classes, soit des modules autonomes accomplissant certaines tâches. Ces classes permettent de créer des objets par l'instanciation de ces classes.

La POO permet de développer des applications à partir d'objets, c'est-à-dire, d'entités possédant des propriétés, des méthodes et des événements, ces objets pouvant être une page Web, un formulaire, un tableau, une chaîne de caractères, un nombre, une image, etc..

Les propriétés sont des méthodes fournissant un accès à des valeurs simulant celles des champs. Les propriétés (ou attributs)d'un objet contiennent les valeurs relatives à cet objet, telles que la taille d'un tableau, le type de données d'un nombre, la contenu d'une chaîne de caractères, etc..
Les propriétés peuvent être simplement lues pour une affectation ou pour un affichage, ainsi que modifiées pour un paramétrage de l'objet à certaines valeurs.

Les méthodes d'un objet représentent les opérations que cet objet peut accomplir comme l'ajout d'une valeur dans un tableau, la concaténation d'une chaîne de caractères, la conversion du type de données d'un nombre.

Les événements d'un objet consistent en la capture d'une action sur cet objet, à l'image d'un clic de souris sur un bouton, la soumission d'un formulaire, le chargement et déchargement d'une page Web.

Les objets sont issus d'une instanciation de classe, ces dernières lui fournissant des propriétés, des méthodes et des événements, soit les membres de cette classe.

Une classe est un type référence encapsulant des données (champs et constantes), ainsi qu'un comportement (méthodes, propriétés, indexeurs, événements, opérateurs, constructeurs et destructeurs), pouvant contenir des types imbriqués.

Les champs représentent des variables contenant des valeurs.

Les constantes représentent des champs contenant des valeurs fixes.

Les indexateurs permettent d'indexer un objet par l'intermédiaire des méthodes d'accès get et set.

Les opérateurs permettent d'inclure les opérations mathématiques de base dans les classes par l'intermédiaire de la surcharge des opérateurs.

12.1 / Les concepts fondamentaux de la POO

Les langages orientés objets assimilent trois concepts fondamentaux :

1. l'encapsulation,
2. l'héritage,
3. et le polymorrphisme.

EncapsulationL'encapsulation consiste en la capacité d'un objet à masquer ses données et méthodes internes, rendant uniquement accessibles les parties prévues de l'objet par le programme.

L'encapsulation est la capacité que possède un objet de masquer certains de ses éléments tout en fournissant un accès à d'autres éléments constituant l'interface utilisateur.

Les méthodes et les propriétés d'un objet peuvent être divisées en membres visibles nécessaires au paramètrage et aux opérations de l'objet demandés par l'utilisateur, et en membres invisibles participant à l'implémentation de l'objet.

L'utilisation des modificateurs d'accès permet d'appliquer les principes d'encapsulation, en définissant des niveaux de visibilité (privé, public, protégé) des membres d'une classe.

AbstractionL'abstraction permet d'accroître la concentration des programmeurs sur la modélisation d'un problème par du code plutôt que sur la manière dont les résultats seront obtenus.

Un nom clair, exprimé en langage naturel, pour une classe permettra de connaître avec certitude quelles fonctionnalités accomplissent cette classe.

Ainsi, l'utilisation d'une classe sera d'autant plus intuitive si son nom est explicite, tout comme ceux de ses interfaces et de ses membres.

HéritageL'héritage consiste en la création d'une classe à partir d'une classe existante, permettant de construire une hiérarchie de classes.

La nouvelle classe hérite automatiquement de l'ensemble des membres de la classe de base et par conséquent, de toutes les fonctionnalités de cette dernière.

PolymorphismeLe polymorphisme caractérise la possibilité de définir plusieurs méthodes avec un nom identique, mais des paramètres différents. La méthode attendue est, alors, choisie en fonction des paramètres fournis lors de son appel.

Le polymorsphisme permet d'appeler précisément la méthode de la classe instanciant l'objet en cours, dans une hiérarchie de classes. Ainsi, un objet issu d'une classe dérivée pourra appeler la méthode de cette dernière, tout en laissant de côté les autres méthodes de même nom dans la hiérarchie de classes du programme.

Le polymorphisme constitue, également, un moyen d'extension d'un programme sans nécessiter la modification du code existant.

13 / Installation sur Windows du Trio PHP/MySQL/PHPMyAdmin

Le couple PHP/MySQL associe un langage de script multi-plateformes à un système de base de données efficace, dans le but de créer des applications Web dynamiques. PHPMyAdmin est une interface graphique écrite en PHP et destinée à la manipulation et à la gestion de base de données MySQL.

phpMyAdmin possède les fonctions suivantes :

• Création et suppression des bases de données,
• Gestion des privilèges d'accès aux bases de données,
• Ajout, édition et suppression d'enregistrements et de champs
• Exécution de requêtes SQL,
• Gestion des clés et index sur les données,
• Optimisation des tables de données,
• Importation ou exportation des données à partir d'archives compressées ou de fichiers texte, CVS ou XML
• Administration d'un ou plusieurs serveurs de base de données et d'uniques base de données

En premier lieu, il faut télécharger les dernières versions stables de ces outils.

• PHP : http://www.php.net/downloads.php
• MySQL : http://www.mysql.com/downloads/index.html
• PHPMyAdmin : http://www.phpmyadmin.net/

En ce qui concerne PHP, il est plus simple de télécharger la version PHP XXX installer permettant une installation automatisée à l'aide d'un exécutable .exe et également la version compressée au format ZIP contenant plusieurs fichiers importants.

Une fois en possession de ces derniers, une décompression des fichiers s'impose afin d'obtenir les fichiers installables.

A ce stade, vous lancez l'application PHP XXX installer, en repérant le répertoire d'installation, en général C:\PHP, dans lequel vous collerez ensuite, le contenu du dossier php-XXX-Win32.

L'installation de MySQL ne nécessite qu'un simple double-clic sur le fichier setup.exe présent dans le répertoire mysql-XXX-win.

Le contenu du dossier phpMyAdmin-XXX doit être recopié à la racine du site Web par défaut, soit dans le répertoire www ou wwwroot. Par ailleurs, il peut être préférable de renommer le dossier phpMyAdmin-XXX en phpMyAdmin, permettant un accès simple et court à l'interface d'administration (http://www.site.net/phpmyadmin/).

Désormais, il faut configurer l'ensemble de ces outils afin que chacun fonctionne dans la plénitude de leurs moyens et se reconnaisse sans problème.

Dans un premier temps, il faut copier tous les fichiers .dll et autres présents dans les répetoires c:\php\dlls\ et c:\php\extensions\ dans le dossier system32 ou system (si le premier n'existe pas) de Windows.

L'édition par le bloc-notes du fichier php.ini localisé dans le répertoire de Windows, en général c:\windows ou encore c:\winnt, doit permettre de configurer les extensions PHP.

;Extrait du fichier php.ini
;Windows Extensions
;Note that MySQL and ODBC support is now built in, 
;so no dll is needed for it.
;
extension=php_bz2.dll
extension=php_cpdf.dll
extension=php_crack.dll
extension=php_curl.dll
extension=php_db.dll
extension=php_dba.dll
extension=php_dbase.dll
extension=php_dbx.dll
extension=php_domxml.dll
extension=php_exif.dll
;extension=php_fbsql.dll
;extension=php_fdf.dll
;extension=php_filepro.dll
extension=php_gd.dll
;extension=php_gd2.dll
extension=php_gettext.dll
;extension=php_hyperwave.dll
extension=php_iconv.dll
;extension=php_ifx.dll
;extension=php_iisfunc.dll
extension=php_imap.dll
;extension=php_interbase.dll
extension=php_java.dll
extension=php_ldap.dll
extension=php_mbstring.dll
;extension=php_mcrypt.dll
extension=php_mhash.dll
extension=php_mime_magic.dll
extension=php_ming.dll
extension=php_mssql.dll
extension=php_msql.dll
;extension=php_oci8.dll
extension=php_openssl.dll
;extension=php_oracle.dll
extension=php_pdf.dll
extension=php_pgsql.dll
extension=php_printer.dll
extension=php_shmop.dll
extension=php_snmp.dll
extension=php_sockets.dll
;extension=php_sybase_ct.dll
extension=php_w32api.dll
extension=php_xmlrpc.dll
extension=php_xslt.dll
extension=php_yaz.dll
extension=php_zip.dll

Le point-virgule permet de désactiver l'extension attenante. Chacune des extensions actives dans PHP doit obligatoirement se trouver dans le répertoire c:\php\extensions\, sinon un message d'erreur apparaitra lors du lancement de PHP.

La vérification de la bonne installation des extensions PHP, peut s'effectuer par l'intermédiaire de l'instruction phpinfo().

Pour cela, il suffit de créer un document PHP, lequel sera dénommé phpinfo.php et enregitré sous la racine de votre site Web par défaut.

<?php
  phpinfo();
?>

Le chargement de ce fichier affichera toutes les informations relatives à PHP. Si des erreurs d'installation subsistent, des messages d'erreurs seront affichés.

Si votre système utilise le kit de développement Java (JDK), vous devrez modifier en conséquence le fichier php.ini.

;Extrait du fichier php.ini
[Java]
java.class.path = .\php_java.jar
java.home = C:\j2sdk
java.library = C:\j2sdk\jre\bin\hotspot\jvm.dll 
java.library.path = .\

Vous pouvez de même modifier la variable register_globals afin d'autoriser l'utilisation des variables globales.

register_globals = On

De même, plusieurs autres domaines peuvent être configurés dans ce fichier de configuration de PHP, tels que les chemins et répertoires (Paths and Directories), les sessions, le téléchargement de fichiers (File Uploads), etc..

Les accès aux bases de données peuvent également être configurés dans le fichier php.ini, mais cela n'est pas recommandé pour des raisons de sécurité.

La configuration de PHPMyAdmin s'effectue par l'entremise du fichier config.inc.php situé dans le répertoire phpMyAdmin.

//Extrait du fichier config.inc.php
...
$cfg['Servers'][$i]['host']          = 'localhost';
// MySQL hostname
$cfg['Servers'][$i]['port']          = '';
// MySQL port - leave blank for default port
...
$cfg['Servers'][$i]['auth_type']     = 'config';
// Authentication method (config, http or cookie based)?
$cfg['Servers'][$i]['user']          = 'root';
// MySQL user
$cfg['Servers'][$i]['password']      = '';
// MySQL password (only needed with 'config' auth_type)
...

Lors de l'installation de MySQL, un compte par défaut est automatiquement créé, il s'agît de l'utilisateur root sans mot de passe.

Donc, il est possible d'ouvrir l'interface d'administration PHPMyAdmin avec la configuration par défaut, mais cela devra être immédiatement rectifié pour des raisons de sécurité évidentes.

L'ouverture de l'interface s'accomplit en lançant son navigateur Web, puis en saisissant dans la barre d'adresse le chemin adéquat.

http://www.site.com/phpMyAdmin/index.php
ou
http://localhost/phpMyAdmin/index.php

A partir de là, vous cliquez sur le lien Privilèges présent sur la page de droite.

La table user contient les comptes d'utilisateurs du système de gestion de base de données de MySQL.

Modifiez le compte d'utilisateur root en spécifiant un mot de passe dans les champs appropriés.

En rechargeant PHPMyAdmin, on pourra remarquer que l'accès à l'interface graphique est refusée puisque la configuration initiale du fichier config.inc.php n'est plus valable.

Dans ce cas, il suffit d'éditer le fichier précité et d'affecter le mot de passe correspondant à la variable $cfg['Servers'][$i]['password'].

14 / Création de fichiers PDF

Le documents PDF (Portable Document Format) possèdent la particularité de pouvoir être lus indépendamment de toutes plateformes (Windows, Mac, Linux, etc.) tout en conservant rigoureusement la mise en page.

Néanmoins, le format PDF a été conçu par l'éditeur de logiciels graphiques, Adobe (Acrobat Reader, Photoshop, Premiere, Golive, etc.) et demeure donc un format propriétaire que la plupart des logiciels d'édition ne gère pas.

Heureusement, il n'est pas utile de s'équiper du très coûteux logiciel, Adobe Acrobat. De simples utilitaires souvent gratuits où d'un coût modique suffiront à créer des documents PDF à l'allure professionnelle.

Il est possible d'opter pour différentes solutions, telles que le couple Ghostview et Ghostscript (Windows, Mac, Linux), HTMLDOC (Windows, Linux), PDF995 (Windows) ou encore d'autres.

Dans un premier temps, il vous faudra télécharger les logiciels choisis et les installer sur votre configuration.

• En ce qui concerne Windows, il suffit de lancer les fichiers exécutables et suivre la procédure d'installation.
• Pour Linux, vous avez parfois le choix entre des fichiers .rpm se comportant comme des fichiers exécutables Windows ou les archives .tar.gz.

  Décompression de l'archive Archive.source.tar.gz
  % tar xzf Archive-source.tar.gz 
  Installation du logiciel
  % cd Archive
  % ./configure
  % make

• Au niveau du Mac, il suffit de double-cliquez sur les fichiers d'installation.

Il est souhaitable également de télécharger et installer l'utilitaire Adobe Acrobat reader afin de vérifier d'une manière optimum vos travaux.

Maintenant, il est nécessaire d'installer un pilote d'impression postscript sur votre configuration Windows. En principe, la plupart des distributions Linux, installe directement un pilote d'impression Postscript, voire même un pilote PDF.

• Cliquez sur le menu Démarrer -> Paramètres -> Imprimantes,
• Double-cliquez sur Ajout d'imprimante,
• A l'ouverture de l'Assistant Ajout d'imprimante, cliquez sur Suivant,
• Si besoin est, cochez Imprimante locale, puis cliquez sur Suivant,
• Sélectionnez le port imprimante, en ganéral LTP1, puis cliquez sur Suivant,
• Sélectionnez une imprimante Laser Postscrit de préférence comme l'HP Color LaserJet 8500 PS, puis cliquez sur Suivant,
• Donnez un nom à l'imprimante, puis cliquez sur Suivant,
• Donnez éventuellement un nom de partage à cette imprimante, puis cliquez sur Suivant,
• Cliquez sur Suivant jusqu'à la fin de l'Assistant Ajout d'imprimante, et enfin cliquez sur Terminer pour valider l'installation.

Pour vérifier le bon fonctionnement de cet installation, ouvrez un document textuel ou une page html quelconque, puis cliquez sur Fichier -> Imprimer. Sélectionnez l'imprimante Postscript (par ex.: HP Color LaserJet 8500 PS) et validez l'impression. Normalement une boîte de dialogue devrait vous demander de saisir le nom du fichier de sortie.

Lorsque vous imprimez dans un tel fichier, l'extension de ce dernier doit donc être généralement .ps.

nom_du_fichier_dimpression.ps

A partir de ce genre de fichier, Ghostview peut créer très facilement un fichier PDF. Il suffit d'ouvrir le fichier Postscript avec le logiciel, puis de le convertir en cliquant sur File -> Convert.... Dans la boîte de dialogue, il faut choisir le type pdfwrite et une résolution. Après la validation, le nom du fichier de sortie est demandé avant d'obtenir un document PDF.

La génération d'un fichier postscript est possible à partir de n'importe quelle application en effectuant une impression vers un fichier. Ensuite Ghostview se charge de convertir le document postscript dans le format PDF.

Avec PDF995, la procédure demeure semblable à l'exception du format du document résulant de l'impression vers un fichier. En effet, PDF995 génére directement le fichier PDF et donc ne nécessite pas de passer par une phase de conversion. Egalement, lors de l'installation du logiciel, PDF995 installe sa propre imprimante postcript locale portant d'ailleurs le nom de l'application.

Quant à HTMLDOC, la procédure est différente :

• Dans ce cas, il faut ouvrir le logiciel,
• Ajouter soit des fichiers, soit des adresses URL et sélectionner l'option Web Page à partir de l'onglet Input,
  
• Puis sélectionner le format PDF et saisir le nom du fichier de sortie à partir de l'onglet Output.
  
• Enfin, un clic sur Generate permet de générer le document PDF.

HTMLDOC autorise l'enchaînement de plusieurs documents distincts afin de ne produire qu'un seul et unique fichier PDF. De plus, il est le seul des trois logiciels à créer automatiquement des liens au sein des documents PDF résultants. En outre, diverses options permettent de régler plus précisément les marges, les couleurs, ainsi que l'encryptage.

Il reste donc simple et rapide de créer des documents PDF à partir de quasiment n'importe quelle source, puisqu'il suffit dans la plupart des cas d'imprimer vers un fichier postscript puis de convertir ce dernier dans le format PDF.

15 / Les lignes de commandes

Les lignes de commande utilisables aussi bien sur Windows que Linux ou d'autres systèmes d'exploitation, permettent de lancer des actions monotâches à partir de l'invite de commandes MS-DOS ou de la console Linux.

Chaque commande MS-DOS ou Linux propose une aide en ligne en utilisant respectivement les options /? ou --h et --help. Il est possible également d'utiliser les commandes spécifiques d'aide, c'est-à-dire help pour MS-DOS et man pour Linux.

Windows
mkdir /?
help shift

Linux
tty --help
man ls

15.1 / Les commandes MS-DOS

Les commandes MS-DOS permettent d'exécuter des tâches à partir de l'invite de commandes, parfois très utiles dans le cadre de développement avec des langages comme Java ou C#.

15.2 / Les commandes Linux

Les lignes de commandes sont particulièrement importantes dans l'environnement Linux. Elles permettent d'exécuter des tâches parfois très utiles dans le cadre de développement d'application, de maintenance ou encore de configuration du système.

16 / Les fichiers batch

Les fichiers batch permettent d'exécuter une série d'instructions passées en ligne de commandes. Cela fonctionne sur les invites de commandes proposée par Windows (MS-DOS) ou Linux (Terminaux).

Les fameux écrans noirs invitent l'utilisateur à saisir des instructions afin d'effectuer des tâches précises.

Affichage de la date courante
c:\>date /T [Validez]

Affichage de l'heure courante
c:\>time /T [Validez]

Changement de répertoire
c:\>cd .\travail\trimestre2\ [Validez]

Edition d'un fichier
c:\travail\trimestre2\>edit cours.txt [Validez]

Parfois, il peut être utile de lancer plusieurs instructions les unes à la suite des autres afin d'atteindre un but précis.

c:\>d: [Validez]
d:\>cd travail [Validez]
d:\travail\>cd cours [Validez]
d:\travail\cours\>cd temporaire [Validez]
d:\travail\cours\temporaire\>del *.* [Validez]
d:\travail\cours\temporaire\>cd .. [Validez]
d:\travail\cours\>rd temporaire [Validez]

Dans ce cas, plutôt que de taper cette suite de commandes, surtout si elle est destinée à être répétée, il sera préférable d'utiliser un fichier batch.

rem Fichier : effacement.bat
rem Empeche l'inscription des lignes de commandes !
@echo off
rem Efface la console
cls
rem Affiche du texte a l'ecran
echo Effacement du repertoire temporaire et de ses fichiers
rem Marque une pause
pause
d:
cd travail
cd cours
cd temporaire
del *.*
cd ..
rd temporaire
echo Les fichiers temporaires et le répertoire ont bien ete effaces !

L'enregistrement de ce genre de texte dans un fichier portant l'extension .bat pour Windows et .sh pour Linux, puis l'appel de ce fichier à partir de la console, permettront de lancer automatiquement le traitement attendu.

c:\>effacement.bat [Validez]

Une particularité importante des fichiers batch est qu'ils peuvent recevoir de un à neuf arguments.

rem Fichier : bienvenue.bat
@echo off
echo Bienvenue %1 !

c:\>bienvenue Frederic [Validez]
Bienvenue Frederic !

En fait, il existe dix arguments possible, il s'agît du nom du fichier batch lui même, portant la référence %0.

rem Fichier argument.bat
@echo off
cls
echo %0

C:\argument [Validez]
c:\argument

De cette manière, l'utilisateur du fichier batch pourra saisir des informations particulières au traitement attendu.

rem Fichier : suppression.bat
@echo off
cls
%1:

cd %2
del *.*
echo Effacement des fichiers !
cd \

rem Si le troisieme argument est egal a n alors allez a fin
if "%3"=="n" goto fin
rd %2
echo Effacement du repertoire %2 !

rem Etiquette de fin
:fin

C:\>suppression d repertoire o [Validez]
D:\dd\*.*, Êtes-vous sûr (O/N) ? o
Effacement des fichiers !
Effacement du repertoire dd !
D:\>

Dans cet exemple, une instruction conditionnelle if est utilisé afin de tester un argument et en fonction de ce dernier un certain traitement sera ou ne sera pas appliqué. En l'occurrence, le troisième argument détermine si le répertoire cible doit être effacé après les fichiers.

Il est possible d'utiliser plus de neuf arguments à l'aide d'une commande de décalage : shift.

rem Fichier : arguments.bat
@echo off
:continue
if "%1"=="" goto fin
echo %1
shift
goto continue
:fin
echo Lecture des arguments terminee !

C:\>arguments 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 [Validez]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Lecture des arguments terminee !

Les fichiers batch peuvent également utiliser des variables, initialisées à l'aide de la commande set.

rem Fichier variable.bat
@echo off
set repertoire=%1
set fichier=%2

if exist %repertoire% goto suite
echo Le repertoire %repertoire% est introuvable !
goto fin

:suite
echo Le repertoire %repertoire% a ete trouve !
cd %repertoire%
if exist %fichier% goto suivant
echo Le fichier %fichier% est introuvable !
goto fin


:suivant
echo Le fichier %fichier% a ete trouve !
type %fichier%
echo .../...
echo Traitement termine !

:fin

C:\>variable repertoire fichier.txt [Validez]
Le repertoire repertoire a ete trouve !
Le fichier fichier.txt a ete trouve !
Le contenu du fichier .../...
Traitement termine !
E:\repertoire\>

Les variables ne peuvent délivrer leur contenu qu'à condition d'encadrer leur identificateur avec des signes de pourcentage %, sinon sera utilisé dans une expression, l'identificateur de la variable, et non sa valeur.

Une autre commande intéressante n'existe malheureusement plus dans les versions récentes de Windows. Il s'agît de la commande choice procurant une structure de choix particulièrement utile et puissante.

rem Fichier : choix.bat
:menu
echo A - Compilez un fichier source
echo B - Exécutez un fichier classe
echo C - Consultez un fichier source
echo D - Quittez le menu
echo E - Fermez la console

choice /c:abcde
if "%errorlevel%"=="A" goto compil
if "%errorlevel%"=="B" goto exec
if "%errorlevel%"=="C" goto edite
if "%errorlevel%"=="D" goto fin
if "%errorlevel%"=="D" goto quit

:compil
javac %1.java
goto menu

:exec
java %1
goto menu

:edite
edit %1.java
goto menu

:quit
exit

:fin

C:\>choix fichier

Les fichiers batch proposent donc une solution simple pour automatiser des tâches répétitives et plus ou moins complexes. Par exemple dans le cas des compilations Java, il peut être souhaitable d'initialiser certaines variables d'environnement nécessaires.

rem Fichier : compilexec.bat
@echo off
set path=c:\j2sdk\bin\;%PATH%

if not "%3"=="" goto init
set repertoire=%1
set fichier=%2
goto suite

:init
set repertoire=%2
set fichier=%3
:suite
set classpath=c:\%repertoire%\classes\
set source=c:\%1\sources\
set direction=c:\%1\classes\
javac -classpath %classpath% 
                                     -d %direction% %source%%fichier%.java
echo La compilation a ete accomplie avec succes !

java -classpath %classpath% %fichier%
echo L'execution s'est deroulee avec succes !

C:\compilexec projet repertoire fichier.java [Validez]
La compilation a ete accomplie avec succes !
...
L'execution s'est deroulee avec succes !

17 / Le système Informatique

Un système informatique (SI) est composé de deux parties : le matériel (hardware) et le logiciel (software). Un SI permet de traiter des informations reçues en entrée, et retourne d'autres informations en sortie.

Par exemple, deux nombres et un opérateur d'addition sont fournis par un opérateur via un clavier et le SI retourne sur un écran, le résultat d'un traitement applicatif qui est la somme des deux nombres. Dans ce cas, en parfaite symbiose, le logiciel et le matériel ont concouru à la saisie de données d'entrée, au traitement des informations et à l'affichage de données de sortie.

Le matériel est un ensemble de composants destiné à acquérir des informations extérieures (clavier, souris, webcam, scanner, etc.), à accomplir des traitements internes (processeur, CPU : Central Processing Unit, etc.), à stocker des informations dans des mémoires de masse (disque dur, disquette, cédérom, DVD ROM, etc.) et à restituer le résultat des traitements (écran, imprimante, carte son, etc.).
Le matériel est une machine possédant des entrées et des sorties, permettant le traitement de données.

Les données convergeant vers des entrées et divergeant vers des sorties sont des informatons compréhensibles par un être humain. Par exemple, un paragraphe saisi au clavier, ou une page numérisée sont directement interprétables par l'homme, de même que des paroles émises par l'intermédaire de moyens phoniques ou un document web affiché sur un moniteur. Par contre, ces informations sont converties dans un langage compréhensible par le matériel et en particulier le processeur ou unité de traitement. En l'occurrence, ces informations sont des données binaires, soit une suite de bits dont chacun peut prendre la valeur 0 ou 1 (false ou true, faux ou vrai, fermé ou ouvert) que l'ensemble du système périphérique convertit au gré des besoins.

La plus petite information binaire est un bit. Les bits sont regroupés dans des octets (bytes), soit des groupes de huit bits. Les octets constituent des mots de un, deux, quatre ou huit octets directement soumis au processeur. Un processeur 32 bits pourra traiter un mot de 64 bits en utilisant deux temps d'horloge. En effet, l'unité de traitement synchronise ses opérations par rapport à une horloge (quartz) envoyant des signaux à intervalles réguliers, il s'agît en fait, de la fréquence du processeur. Plus, cette fréquence est élevée, plus rapidement seront effectués les calculs et les échanges d'informations entre le système périphérique et l'unité de traitement. Différentes mémoires sont mises à la disposition du CPU afin de stocker les différentes informations relatives au fonctionnement du système informatique (ROM : Read Only Memory, mémoire permanente) et de conserver des informations provenant de différentes sources comme le système périphérique ou le processeur lui-même (RAM : Random Access Memory, mémoire volatile) d'accélérer le traitement des données (mémoire cache) et de charger des mots binaires avant traitement (registres intégrés au processeur).

Le CPU commande tout le système informatique via un circuit électrique appelé bus système. Toutes les mémoires sont connectées à ce bus possédant également une certaine fréquence. L'ensemble des périphérique est également relié à ce circuit par l'intermédiaire de dispositifs d'intégration appelés interfaces. Ces dernières fonctionnent comme des mémoires pour le processeur, dans lesquelles il peut lire et écrire des données binaires.

Le CPU est capable de faire des opérations élémentaires telles que l'addition, la soustraction, la multiplication, les décalages, des opérations logiques ET, OU, NON, etc.. Lorsqu'un calcul est éffectué par le processeur, plusieurs informations binaires lui sont d'abord transmises, comme des opérandes droite et gauche ainsi qu'une instruction d'addition (par exemple), puis en fonction de ces données, un résultat est produit et est retourné à l'utilisateur.

Toutes les opérations élémentaires précitées que le processeur est capable de faire, sont désignées chacune par une information binaire spécifique stockée en mémoire centrale. Ces instructions constituent le langage machine, en quelque sorte le logiciel de programmation le plus prôche du processeur. Chacune de ces instructions déclenche une commande de base du processeur comme dans l'exemple précedent : rechercher des valeurs dans la mémoire pour charger des registres, puis additionner les deux registres et stocker le résultat dans un autre registre avant utilisation.
Le langage machine n'est pas universel puisque des systèmes informatiques Macintosh ou PC (Personal Computer) ne gère pas les instructions de la même façon si bien que ces machines sont incompatibles entre elles à moins de posséder un émulateur manquant souvent de performances.

Le système d'exploitation (OS : Operating System) de tout système informatique s'appuie sur le langage machine pour accomplir la moindre de ses actions. L'OS est un logiciel chargé des opérations de bas niveau, c'est-à-dire au plus près du matériel. Les données et les instructions sont décomposées en unité élémentaires par le système d'exploitation avant de les soumettre à l'unité de traitement.

Il existe différents types d'OS sur le marché comme DOS, Unix, Mac OS, Windows, OS/2 et Linux. Tous n'ont pas les mêmes caractéristiques, et ne sont pas tous employés dans les mêmes domaines. Par exemple la famille Unix (AIX, Digital Unix, HP-UX, NetBSD, OpenBSD, SCO, Solaris, SunOS), sans conteste la plus mature, est utilisée dans le domaine des serveurs professionnels, Mac OS se positionne dans la sphère de la PAO (Publication Assistée par Ordinateur), du graphisme ou du multimédia, et Windows s'éparpillant dans tous les secteurs, équipe les particuliers comme les entreprises.

Les systèmes d'exploitation se démarquent les uns des autres par certaines capacités de fonctionnement interne de leur noyau (kernel). Par exemple, DOS est mono-utilisateur et monotâche, la gamme des Windows XX destinée aux particuliers sont de types mono-utilisateur et multitâches, tandis qu'un Unix est multi-utilisateurs et multitâches. Les termes mono/multi-utilisateurs et mono/multitâches signifient respectivement que l'OS est capable d'accepter sur un même SI un ou plusieurs utilisateurs et exécuter une ou plusieurs opérations simultanément. D'autre part, certains OS seront excellents dans des secteurs précis car leur jeu d'instructions élémentaires et leur architecture seront plus ou moins bien adaptés à l'utilisation qui en sera faite.

Les interfaces utilisateurs selon les systèmes d'exploitation diffèrent entre eux. Acutellement, l'interface graphique utilisateur (GUI : Graphic User Interface) propose une ergonomie sans conteste efficace et conviviale. Quasiment tous les OS possèdent une inteface fenêtrée pilotable à la souris, permettant une navigation visuelle jusqu'au coeur du système. Néanmoins, le mode console (ligne de commandes) des anciens Unix, DOS ou Linux demeurent encore aujourd'hui incontournable dans le secteur des réseaux et de la sécurité informatique.

Divers programmes exécutables intégrés dans les systèmes d'exploitation permettent de configurer l'OS et le matériel (make, lsmod, menuconfig sous Linux, regedit, ipconfig sous Windows), de renseigner les utilisateurs (help, perfmon, setver sous Windows, history, diff, hdparm sous Linux, ) ou d'effectuer diverses tâches (edit, notepad, calc sous Windows, tar, tty, sh sous Linux).

Le système de fichiers est un composant extrêmement important d'un OS puisque c'est à lui que revient l'organistation des mémoires de masses. Dans un premier temps, les différents supports physiques tels que les disques durs ou les disquettes doivent subir un formatage spécifique déterminant la manière dont sera structurée les données binaires. Un disque dur sera ainsi divisé en secteurs, pistes et cylindres et une table d'allocation de fichiers située en général dans le premier secteur servira à repérer la localisation de chaque fichier et dossier.

Les fichiers sont une collection d'octets avec une structure particulière dépendant de son type (Feuille de calcul, document texte, image, programme source, exécutable, bibliothèque, etc.). Leur taille dépend de leur contenu, un fichier texte comprend des caractères pesant chacun un octet, tandis qu'un exécutable peut contenir des instructions binaires pesant chacune de un à huit octets. L'utilisation des fichiers passent obligatoirement par leur chargement en mémoire centrale (RAM). Seulement à ce moment, ils pourront être exécutés, consultés, ou encore modifiés. Les fichiers possédant en général un nom et une extension (identificateur.ext) sont regroupés dans des répertoires, lesquels peuvent être également placés dans d'autres répertoires, formant ainsi une arborescence parfaitement connue par la table d'allocation. Tous les fichiers y compris les fichiers systèmes sensibles peuvent être exploitables par des utilisateurs quelconques comme sous Windows 9X ou une segmentation des mémoires de masse est créée afin que les utilisateurs n'accèdent qu'aux fichiers autorisés par rapport à leurs droits d'accès à l'image de Unix, Linux, Windows NT, 2000...

Un système informatique est une combinaison hautement interdépendante de matériels (processeur, périphériques, etc.) et de logiciels (langage machine, système d'exploitation). Les OS proposent une interface en mode graphique ou parfois en ligne de commandes garantissant une compréhensibilité entre l'utilisateur et la machine pour finalement exploiter au mieux l'ensemble des possiblités qu'offrent un système informatique. A partir de l'interface utilisateur (UI : User Interface), le développeur sera en mesure de programmer des applications qui viendront se greffer sur le SI et ainsi enrichir ce dernier d'une nouvelle couche applicative améliorant substantiellement l'UI.

17.1 / Architecture d'un Système Informatique

Un système informatique est composé de plusieurs éléments matériels dont la synergie permet la manipulation ou la visualisation d'informations par rapport aux qualités réceptives de l'homme.

Le processus de traitement de l'information semble transparente pour l'utilisateur car chaque action entrepris par l'utilisateur est transformée en une suite de données binaires que les différents composants seront alors capable de comprendre et d'interpréter.

Le CPU ou l'unité centrale de traitement (Central Processing Unit) est souvent connu sous le nom de processeur. Ce composant est au coeur du système informatique, quasiment toutes les informations binaires sont traitées par le processeur. Ce-dernier peut selon son architecture, faire des calculs sur des mots binaires de un octet (Intel 8088, Commodore, Apple II), deux octets (Intel 8086, i286), quatre octets (i386, AMD 386), huit octets (Intel Pentium, AMD Athlon, PowerPC) et plus pour les gros systèmes informatiques. La fréquence et la densité des composants élémentaires sont également des caractèristiques importantes du processeur. La loi de Moore datant de 1966 (Gordon E. Moore était alors directeur de la recherche chez Fairchild) prévoyait un doublement des capacités d'un processeur tous les dix-huit mois. Ainsi, en moins de deux décennies, de 16 mégahertz avec 275 000 transistors pour l'intel i386 en 1985, les processeurs du millénaire comme l'Intel Pentium IV dispose de 42 millions de transistors pour une fréquence de 1,5 gigahertz.

L'UAL ou Unité Arithmétique et Logique (ALU : Arithmetic and Logical Unit) permet de faire des calculs mathématiques tels que l'addition ou la multiplication, et des opérations booléennes telles que le ET, OU et NON. Ainsi, à partir de chaque combinaison binaire (0 et 1) en entrée, l'UAL détermine l'opération à accomplir et produit un résultat binaire en sortie.L'UAL fonctionne dans le mode combinatoire, à l'aide de portes logiques.

Les registres sont des mémoires directement intégrées dans le processeur. Un registre permet de stocker une collection d'octets telle que le résultat de la dernière opération de l'UAL ou la donnée du prochain calcul. Le nombre de registres est limité dans les processeurs, c'est pourquoi les informations binaires n'y font qu'un bref passage, le temps d'un ou plusieurs coups d'horloge.
PLusieurs registres spécifiques servent à accueillir un certain type d'information binaires.
Les registres d'adresses permettent de référencer les adresses des programmes et des données dans les mémoires ROM, RAM et les interfaces. Ces adresses, en fait des nombres binaires, permettent au processeur de récupérer les informations nécessaires à un endroit précis de la mémoire centrale (ROM et RAM) pour l'accomplissement de ses tâches.
Le registre d'instruction sert à stocker l'information binaire désignée par un code opération dédiée à la réalisation d'un calcul arithmétique ou logique prédéfini.

La PC (Partie Commande) pilote le processeur en opérant des instructions de branchement entre les registres. A chaque coups d'horloge, la PC ouvre et ferme des portes dans le but d'alimenter l'UAL en donnée et instruction et d'inderdire la collision d'information. Par cet intermédiaire, le processeur traite une opération à la fois dans un intervalle donnée par l'horloge.

Le système informatique est entièrement commandé par l'intermédaire de la PC. Les actions que ce composant est capable d'accomplir sont désignées par des nombres binaires appelés codes opérations, lesquels forment le langage machine propre au fabricant du processeur. Un processeur Intel Pentium IV ne possède pas le même langage machine que son homologue Power Mac G4. Le langage compréhensible par l'homme au plus près du matériel s'appelle l'assembleur regroupant des commandes sous forme de mots clés de trois lettres maximum, comme MOV (déplacement vers un registre), ADD (addition), INC (incrémentation), etc.. Les programmes informatiques, à commencer par le système d'explotation s'appuie sur cette forme primitive de langage pour exécuter des applications plus ou moins évoluées.

18 / Les cycles de développement logiciel

Avant la livraison à un client, le développement d'un logiciel passe par plusieurs étapes définies au cours des deux dernières décennies :

• l'analyse préalable d'un cahier des charges,
• la conception,
• le codage,
• les tests, la validation,
• l'intégration,
• la mise en production,
• la recette* du système et sa validation,
• la maintenance du système.

* La recette est une vérification de conformité du logiciel par rapport aux spécifications théoriques définies au début du projet, avant son déploiement final.

Le développement d'un produit applicatif doit prendre en compte des risques inhérents à cette activité (développement d'interfaces utilisateurs, ou de fonctions inappropriées, non-respect du cahier des charges, problèmes de performance, etc.) et à l'évolution d'une entreprise (calendrier irréalisable, budget inadapté, défection des personnels, etc.).

C'est pourquoi, une société de service en ingénierie informatique doit se conformer à des règles intangibles de développement d'application. A cet effet, il existe plusieurs modèles de cycle de vie d'un logiciel :

• Le modèle en cascade consiste en une succession de phases dont chacune est méthodiquement vérifié avant de passer à l'étape suivante :
  1. faisabilité et analyse des besoins : validation,
  2. conception générale et détaillée : vérification,
  3. intégration : tests d'intégration et tests d'acceptation,
  4. installation : tests du système.
• Le modèle en V repose sur une étroite interdépendance des étapes soumises à une validation avant la prochaine étape et une vérification anticipatoire du produit final :
  1. spécification textuelle,
  2. conception générale,
  3. conception détaillée,
  4. codage,
  5. tests unitaires,
  6. tests d'intégration,
  7. validation.
• Le modèle en spirale s'appuie sur une succession de cycles dont chacun se déroule en quatre phases :
  1. analyse initiale des besoins et des objectifs du cycle (solutions et contraintes) ou analyse à partir du cycle précèdent,
  2. étude des risques, évaluation des solutions de remplacement et éventuellement conception,
  3. développement et vérification de la solution résultant de l'étape précédente,
  4. examen du produit et projection vers le cycle suivant.
• Le modèle par incrément propose un développement du logiciel par morceaux, lesquels sont livrés successivement au client, en venant se greffer à un noyau logiciel.

Le modèle en V demeure actuellement le cycle de vie le plus connu et certainement le plus utilisé.

La première étape, appelé spécification ou analyse des besoins, a pour but de dégager du cahier des charges, toutes les contraintes nécessaires à l'élaboration du logiciel. Trois sortes de contraintes logicielles sont à prendre en considération :

• Les contraintes externes définissent les caractéristiques d'entrée/sortie du logiciel attendues par le client (données à utiliser et à afficher, les exigences ergonomiques, le parc informatique, etc.).
• Les contraintes fonctionnelles caractérisent le fonctionnement interne du logiciel, c'est-à-dire, quels moyens seront mis en oeuvre pour traiter les informations d'entrée/sortie du logiciel (méthode de calcul, intervalle des données, etc.).
• Les contraintes de performances indiquent la vitesse d'exécution du logiciel ou de ses modules, la résolution d'affichage, la précision des données, etc..

Les documents produits (plan de développement du logiciel, spécifications des besoins du logiciel et cahier de recette) au cours de cette phase permettent de passer à l'étape suivante et également de préparer les vérifications de conformité du logiciel.

Cette phase constitue environ 15 pourcents du temps total du cycle de développement.

La conception générale (ou analyse organique générale)a pour objectif de déduire de la spécification, l'architecture du logiciel. Lors de cette phase, plusieurs solutions peuvent être envisagées afin d'en étudier leur faisabilité. A l'issue, un document de conception générale du logiciel est réalisé afin de décrire la structure générale de l'alternative approuvée.

Lors de cette phase, il peut être décider de découper le logiciel en plusieurs modules distincts afin de les sous-traiter par plusieurs équipes de développement. Un module possède une interface permettant son intégration au logiciel global ou à d'autres modules, et un corps pour son fonctionnement interne. Ils sont hiérarchisés de telle façon que des modules de bas niveau s'emboîtent dans des modules intermédiaires, lesquels s'intègrent à un module de haut niveau (noyau logiciel).

Un autre découpage peut être aussi utilisé pour scinder le logiciel en tâches distinctes. L'application contient alors plusieurs sous-ensembles ayant en charge des traitements spécifiques (tâches externes et tâches internes au logiciel), lesquels s'interconnectent entre eux

La phase de conception détaillée (ou analyse organique détaillée) en s'appuyant sur le document de conception générale, énumère l'architecture approfondie du logiciel jusqu'à parvenir à une description externe de chaque sous-ensemble et information utilisable dans le futur logiciel. A partir de cette étape, seront connus toutes les données (variables, constantes, attributs, champs, etc.) et fonctions (procédures, méthodes, etc.) de l'application vue de l'extérieur. Le logiciel peut être entièrement écrit en algorithme. Un langage de programmation est en général validé lors de cette phase. Un document de conception détaillée, ainsi qu'un manuel d'utilisation sont édités afin de respectivement de décrire l'architecture détaillée et la mise en oeuvre du logiciel. Les phases de conception doivent prendre environ 25 pourcents du temps total du cycle de développement.

Des spécifications de tests d'intégration et unitaire sont également produites, à l'issue des deux phases de conception. Elles permettront de confronter le fonctionnement de l'application à son architecture générale et détaillée.

Le codage consiste à écrire avec un langage de programmation chacune des sous-programmes du logiciel. Le développement peut être confié à une seule personne dans le cas d'une application simple ou divisé entre plusieurs équipes de développeurs dans le cas de projets importants. Cette phase durant environ 15 pourcents du temps total du cycle de vie se termine par la production d'un code source.

Les tests unitaires ont pour objectif de vérifier individuellement la conformité de chaque élément du logiciel (fonctions et variables) par rapport aux documents de conception détaillée. Toutes les fonctionnalités internes et externes de chaque sous-programme sont contrôlées méthodiquement. En outre, un contrôle des performances globales et locales est également entrepris. Cette phase consomme aux alentours de 5 pourcents du temps total du cycle de vie et se finalise par la rédaction des résultats des tests.

La phase d'intégration permet de vérifier l'assemblage des différentes parties du logiciel. Les différents modules du logiciel sont successivement intégrés jusqu'à aboutir à la construction complète, en respectant rigoureusement les spécifications des tests d'intégration. Chaque module doit parfaitement être assimilé sans que le fonctionnement des modules précédemment intégrés n'en soit aucunement affecté. Les résultats de cette phase sont consignés dans un document des tests d'intégration. En général, une présentation du logiciel est également réalisée. Les tests d'intégration représentent en moyenne 20 pourcents du temps total du cycle de développement.

La dernière phase a pour vocation de valider le logiciel dans son environnement extérieur. Le produit applicatif est mis en situation d'utilisation finale afin de vérifier s'il répond parfaitement aux besoins énoncés dans les spécifications textuelles (première phase). Un document appelé résultat de la recette est produit au terme de la phase de validation qui dure 10 pourcents du temps total du cycle de vie du développement du logiciel.

La finalité du cycle de vie en V consiste à parvenir sans incident à livrer un logiciel totalement conforme au cahier des charges. Lors de la phase de spécification textuelle, une négociation avec le client permet d'affiner ou d'enrichir les besoins à propos de certains points techniques omis ou obscurs dans le cahier des charges. Lorsque la spécification est validée, la suite du processus de développement doit être parfaitement encadré, contrôlé et approuvé de telle sorte qu'à aucun moment, il ne soit possible de diverger des règles énoncées lors de la première phase.

19 / L'algèbre relationnelle appliquée au SGBDR

L’algèbre relationnelle a été introduite par M. CODD en 1970, pour formaliser les opérations sur les ensembles. C’est grâce à ce système formel que l’on peut démontrer l’équivalence des requêtes sur des bases de données relationnelles, et que l’on peut construire des optimiseurs de requêtes.

Les opérations relationnelles permettent de combiner des ensembles de valeurs, appelées relations, entre eux dans le but d’obtenir en fonction du type de l’opération, un certain résultat.

Plusieurs opérations relationnelles peuvent être appliquées à des tables de base de données dans des SGBDR. De telle opérations, appelées requêtes, sont lancées par l’intermédiaire du langage SQL afin d’extraire d’une ou plusieurs tables, une certaine combinaisons de colonnes (ou champs) et de lignes (ou uplets, tuples, enregistrements).

19.1 / Le modèle relationnel

Avant d'aborder les opérations relationnelles à proprement parler, il est nécessaire de définir le vocabulaire adapté au modèle relationnel.

Une base de données comporte une à plusieurs tables contenant diverses informations organisées par colonnes (ou champs) et lignes (ou enregistrements).

Dans le modèle relationnel, une table de données correspond à une relation, désignant un ensemble d'informations au sens mathématique. La relation est-elle même décomposée en attributs et en n-uplets, correspondant respectivement aux colonnes et aux lignes des tables.

Les attributs d'une relation forment un schéma, représentant la structure de cette relation. Le schéma caractérise une relation ainsi que tous les n-uplets qui y sont contenus.

Un n-uplet correspond à une combinaison de valeurs des n-attributs que possèdent la relation. Par exemple, si une relation possède six attributs, alors cette relation sera composée d'un certain nombre de "six-uplets".

Les n-uplets doivent tous être identifiables d'une manière unique. Pour assurer l'unicité d'un n-uplet, il est nécessaire de définir dans une relation, une clé primaire. Cette dernière, peut être un attribut ou une combinaison d'attributs (clé primaire composite), produisant respectivement une certaine valeur ou un ensemble de valeurs qui doit impérativement être unique, afin d'identifier précisément un et un seul n-uplet dans la relation.

Les relations peuvent être reliées à d'autres relations par l'intermédiaire d'une liaison entre des clés identificatrices. Une relation peut contenir une clé étrangère faisant référence à la clé primaire d'une seconde relation. De cette manière, il devient possible de créer, pour les attributs d'une relation, des domaines de valeurs contenus dans d'autres relations liées. Par exemple un attribut dénommé couleur pourrait ne contenir qu'un seul code couleur défini dans une liste externe prédéterminée.

Une clé primaire peut être également une clé étrangère référençant une autre relation.

Les liaisons entre relations possèdent des cardinalités représentant le nombre d'occurrences de valeurs uniques autorisées entre des attributs de même domaine ou ayant le même sens. En fait, il existe trois combinaisons génériques de cardinalités : Un à Un, Un à Plusieurs ou Plusieurs à Plusieurs. La première cardinalité s'applique à une clé primaire et la seconde à une clé étrangère. De cette manière, il est possible de définir pour une relation son type de dépendance avec d'autres relations. Par exemple, un relation dénommée famille contient plusieurs personnes et à l'inverse une personne ne peut appartenir qu'à une et une seule famille (parentale).

Les conventions de présentation définissent qu'une clé primaire doit être soulignée et qu'une clé secondaire doit être suivie d'un signe dièse '#' ou d'une étoile '*'. Dans les modèles d'analyse Merise ou UML (Unified Modeling Language), les cardinalités Plusieurs peuvent être symbolisées par une lettre 'n' ou parfois un signe infini, notamment dans le cas de Microsoft Access.

19.2 / L'union

L’union de deux relations possédant un schéma identique produit une relation résultante. Cette dernière de même schéma que celles dont elle est issue contient l’ensemble des n-uplets appartenant à chacune des deux relations ainsi que les uplets communs aux deux.

Formalisme : R = UNION(Ra, Rb) ou R = Ra U Rb

Langage SQL :
SELECT * FROM Ra
UNION
SELECT * FROM Rb;

19.3 / L'intersection

L’intersection de deux relations possédant un schéma identique produit une relation résultante. Cette dernière de même schéma que celles dont elle est issue contient l’ensemble des n-uplets communs aux deux relations.

Formalisme : R = INTERSECTION(Ra, Rb)

Langage SQL :
SELECT * FROM Ra
INTERSECT
SELECT * FROM Rb;
'ou
SELECT A, B, C FROM Ra
WHERE A IN (SELECT A FROM Rb) 
      AND B IN (SELECT B FROM Rb) 
      AND C IN (SELECT C FROM Rb) ;

19.4 / La différence

La différence entre deux relations possédant un schéma identique produit une relation résultante. Cette dernière de même schéma que celles dont elle est issue contient l’ensemble des n-uplets appartenant à la relation soustraite et n'appartenant pas à l'autre relation.

Formalisme : R = DIFFERENCE(Ra, Rb) ou R = Ra - Rb