lundi 25 avril 2005

Test, vérification et validation

TEST, VÉRIFICATION ET VALIDATION

La qualité d'un logiciel ne fait malheureusement pas souvent partie des processus du développement logiciel au sein des entreprises. Les entreprises qui ont peu de moyens ou pour lesquelles le temps de mise sur le marché est crucial négligent souvent cette étape du développement logiciel.

La qualité d'un logiciel est directement liée aux caractéristiques qui peuvent être mesurées à l'aide de tests et d'inspections.
Plusieurs problèmes qui peuvent avoir des conséquences majeures sur le projet, peuvent être mis en évidence:
  • Identification des exigences des usagers
  • Implémentations des exigences des usagers
  • Facilité d'utilisation et mise à jour de la documentation
  • Maintenance du système
Ces activités, si elles sont négligées, peuvent causer l'échec d'un projet ou tout au moins l'affecter grandement. Le client peut se retrouver avec un système qui ne lui convient pas et ne l'utilisera pas

Ce processus est souvent appelé l'activité V&V (vérification et validation) dans le métier. Le niveau de v & v ne peut être du même niveau pour n'importe qu'elle système. Ne serait-ce que pour des questions de coûts par exemple. Les mesures misent en place pour le développement d'un système bancaire peuvent s'avérer totalement inutile pour la gestion d'un logiciel de pool de hockey.

Plusieurs questions peuvent faciliter les mesures devant être prises pour un projet: quel est le niveau de qualité devant être atteint, les demandes spécifiques du client, les ressources disponibles, le niveau d'expertise, l'échéancier, le niveau de risque pouvant être pris... Les réponses à ces quelques questions permettent d'avoir un petit aperçu des mesures nécessaires pour assurer un minimum de qualité pour le système à développer. Ces pratiques ne sont trop souvent pas réalisées pour les logiciels commerciaux, il suffit de voir le nombre de mises à jour critiques... Une grande partie des problèmes au niveau de la qualité peuvent être enrayés grâce aux tests. Un article sur les tests peut être trouvé dans la section Génie logiciel de ce site.

Les tests

Cette phase est l'une des plus coûteuses en terme de temps et d'argent, elle peut facilement prendre plus de 30% du cycle de développement. Parmi les tests, on retrouve :
  • les tests unitaires qui sont faits par le programmeur afin que chaque module puisse fonctionner sans erreur de programmation
  • les tests fonctionnels qui sont faits par le programmeur ou un spécialiste afin de s'assurer que les exigences fonctionnelles sont implantées convenablement
  • le test du produit afin de s'assurer que le logiciel s'exécute correctement
  • le test du système afin de vérifier si le logiciel fonctionne sur la machine cible (avec les logiciels et matériel du client)
  • le test de validation qui est fait par le client pour vérifier le niveau de qualité
Malheureusement, la compétitivité du marché semble l'emporter sur la qualité. Livrer un système sans faille ne semble plus possible.

Il est difficile de juger du moment où il est opportun d'arrêter les tests. Il est possible de se baser sur des coûts économiques: le coût d'une éventuelle panne du système coûterait plus cher que le coût des tests. Les risques doivent être pris en considération lorsque les tests sont arrêtés.

Automatisation


La phase de tests est souvent réalisée de façon manuelle. Or cette étape peut être de plus en plus automatisée. Certes, il y a une phase d'adaptation au niveau du logiciel, mais le temps et l'argent investis ne seront pas perdus.

Des logiciels qui génèrent des entrées pour un système existent. Les logiciels de ce type permettent de voir comment le logiciel réagira avec 8, 10.. Caractères lorsque le logiciel n'en gère que 5 par exemple. Il est ainsi possible de voir les cas limites du système. Un rapport est créé et les tests passés ou échoués peuvent être rapidement vus. Une fois que les cas désirant être testés sont créés, ils pourront être de nouveau exécutés à chaque version du logiciel afin de voir si de vieux problèmes ne sont pas revenus. En plus de pouvoir être utilisés dans d'autres versions du système, ils peuvent être utilisés à diverses phases des tests. Au final, les tests sont gérés de façon centralisée. Les tests et résultats des tests sont accessibles à tous.

Des outils d'analyse de code existent aussi, ils permettent de savoir si certains standards ont été suivis, de cerner d'éventuels problèmes. Un autre outil facile à mettre en oeuvre est le gestionnaire de suivi de problème. Un exemple de ce type de logiciels est bugzilla. Ce type d'application permet de voir les problèmes fixés, de nouvelles caractéristiques désirées...
Afin d'assurer une réussite des approches vues dans cet article, l'entreprise doit s'assurer de la participation de tous. Plus nos processus de développement logiciels sont défaillants, plus le niveau d'efforts sera exigence. Un suivi plus précis de la gestion du projet devra être réalisé.

Du temps devra être pris pour bien documenter les étapes de développement du système. Les participants aux projets devraient tous connaître les ressources mises à leurs dispositions pour augmenter la qualité du système. Savoir qu'on a des ressources n'est pas tout, il faut aussi les utiliser. Une bonne communication s'avère cruciale pour espérer une réussite d'un projet informatique.

dimanche 24 avril 2005

Les fonctions


FONCTION

Tout comme dans la majorité des autres langages de programmation, il est possible de créer des fonctions.

Simple fonction

La définition d'une fonction est similaire au langage C.

function bonjour()
{
  echo "bonjour"
}

il est aussi possible de faire:

bonjour()
{
  echo "bonjour"
}

Il suffit d'invoquer le nom de la fonction pour qu'elle soit appelée. La définition de la fonction doit être fait avant son appel.

#!/bin/bash
bonjour()
{
  echo "bonjour"
}

bonjour

Argument

Il est possible de passer des arguments à une fonction. Dans la fonction, il suffit de vérifier la valeur de $1, $2...

#!/bin/bash
information()
{
  if [ -n "$1" ]
  then
    echo $1;
  else
    "Aucun paramètre"
  fi
}

information "salut"
#!/bin/bash
information()
{
  if[ -n "$1"]
    echo $1
  else
    echo "Aucun paramètre";
  fi
  return 0
}

information
information "salut"

Argument

Nous allons maintenant créer une fonction qui retourne une valeur.
function min()
{
  if [ -n "$1" ] && [ -n "$2"  ]
  then
    if [ "$1" -lt  "$2" ]
    then
      return $1;
    else
      return $2;
    fi
  fi
}
min 112 13
echo "$? est la plus petite valeur"

Essayer de mettre une valeur supérieure à 256 comme argument.
Prenez note qu'une fonction ne peut renvoyer une valeur supérieure à 256. Cette contrainte provient des codes de sortie. Dans les nombres négatifs, il est possible d'aller beaucoup plus loin. Il suffit d'utiliser une variable globale pour pallier à ce problème.

VAL=
function min()
{
  if [ -n "$1" ] && [ -n "$2"  ]
  then
    if [ "$1" -lt  "$2" ]
    then
      VAL=$1
    else
      VAL=$2
    fi
  fi
}
min 1132 1300

echo "$VAL est la plus petite valeur "

Prenez note de la syntaxe de la déclaration de la variable VAR.
Vous devez utiliser une variable si vous désirez retourner une chaîne de caractère.
Prenez note qu'une variable déclaré dans une fonction à une portée globale au script. Elle peut donc être utilisé partout ailleurs. Pour éviter cela, il faut mettre avant le nom de la variable local lors de son initialisation.

local prenom="paul"

Nous avons complété la partie traitant des fonctions. Un script avec tous les exemples peut téléchargez ici

dimanche 17 avril 2005

Les opérations arithmétiques


LES OPÉRATIONS ARITHMÉTIQUES

Telles que la majorité des langages, les opérations restes les mêmes : +, -, *, /. C'est assez standard comme syntaxe. Il y a cependant quelques différences pour certaines. Il est nécessaire de mettre le mot: let pour plusieurs opérations.

Exposant

Nous devons employer : ** si on désire effectuer l'opération x^y. La commande ci-dessous retournera 125.
let "x=5**3"
echo $x

Modulo

Modulo retourne le reste de la division. On obtiendra donc 2 avec la commande suivante.
let "x=125%3"
echo $x

Constante

Il est possible comme plusieurs langages, d'employer une syntaxe raccourcie pour les opérations : +, -, *, /, %. Ces instructions deviennent alors: +=, -=, *=, /=, %=.
JOURS=" Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche"
for jours in `echo $JOURS`
do
  let "x +=100$"
done

Notez qu'on aurait pu changer += par une des autres instructions qu'on a vues plus haut: -=, *=...*

Contrainte

Bash convient parfaitement pour des opérations sans trop de complexité. Bash emploie des entiers 32bits pour les nombres donc il est impossible d'utiliser des nombres en dehors de l'intervalle : 2147483648, 2147483647 sans obtenir un message d'erreur. Si vous avez une version moindrement récente de Bash cette contrainte est enlevée. Les nombres à virgule flottante ne peuvent être employés. BC ou une librairie mathématique externe doit être utilisée.
BC est un langage qui permet de faire de multiples opérations avec les nombres. Il a une syntaxe similaire au C.

x=$(echo "2+1.3" | bc)
echo $x

Dans le code ci-dessus, il y a quelques nouveautés. Le contenu du echo à l'intérieur de la parenthèse est envoyé à bc. L'emploi de |, envoie la sortie d'une commande à une autre. C'est ce qu'on appelle un pipe (tuyau).

Nous avons complété la partie traitant des opérations arithmétiques. Un script avec tous les exemples peut être téléchargé ici

mercredi 6 avril 2005

A First Course in Database Systems




Ce livre s'adresse au débutant en base de données soucieux de connaitre la théorie. Les concepts mathématiques sont vues. Une autre facette des bases de données est présenté.

Un peu de conception est discuté, mais l'emphase du livre est mise sur l'implémentation de base de données. Chaque concept apporte son lot d'exemple qui facilite énormément la compréhension de passage plus complexe telle que l'algèbre relationnelle.

Le livre passe au travers du langage SQL. On présente souvent la méthode de l'algèbre relationnelle et ensuite son équivalent SQL ce qui permet de mieux comprendre les concepts appris, même si la compréhension de l'algèbre n'est pas requise.

À chaque chapitre, le lecteur est invité à faire les exercices présentés. Des concepts plus avancés tels que la récursion ainsi que le SQL3 sont aussi couverts.

lundi 4 avril 2005

Les boucles


LES BOUCLES

Les boucles sont utilisées pour exécuter x fois une opération. Il existe quelques méthodes pour itérer des commandes.

Boucle for

On affiche tous les jours de la semaine. Ces derniers font partie de la liste.
for jours in Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche
do
  echo $jours
done

Au lieu d'inclure une liste (Lundi, Mardi...), il est possible de passer un paramètre. Par exemple, on pourrait afficher tous les fichiers qui commenceraient par b.
for fichier in b*
do
  echo $fichier
done
Notez qu'on aurait obtenu le même résultat en tapant ls b*
Il est possible de mettre la liste des valeurs dans une variable et ensuite de ce servir de cette dernière.
JOURS=" Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche"
for jours in `echo $JOURS`
do
  echo $jours
done

Jusqu'à maintenant, la boucle for qu'on n'a vue n'avait rien à voir avec celle que plusieurs sont habitués d'utiliser en C. Il est bien sûr possible d'avoir une syntaxe similaire. Dans cet exemple, on affiche les chiffres de 1 à 10 et de 10 à 1.
MAX=10
MIN=0
for(( a=1, b=10; a < MAX, b > MIN; a++,b--))
do
 echo $a $b
done
Notez qu'il est obligatoire de mettre une double parenthèse. Nous avons mis deux conditions dans la boucle, aussitôt qu'une des deux est fausse, la bouche est arrêtée. Changez la valeur de MIN pour 3 par exemple et vous allez comprendre...

Boucle while

Cette boucle teste à l'entré si la condition est vraie et boucle tant que cette dernière est vrai.
i=0
j=5
while [ "$i" -lt "$j" ] # tant que i < j
do
  echo "$i"
  i=`expr $i + 1` #ou i++
done

Boucle until

On pourrait dire que cette boucle est l'opposé de la boucle while. Cette boucle teste à l'entrée la condition et boucle tant que cette dernière est fausse.
i=0
j=5
until [ "$i" -lt "$j" ] # tant que i < j
do
  echo "$i"
  i=`expr $i + 1` #ou i++
done

#on affiche i tant que i et j sont identique, bouclerais à l'infini si on n'avait pas mis la condition de test à l'intérieur.
i=0
j=0
until [ "$i" -lt "$j" ]
do
  echo "$i"
  i=`expr $i + 1` #ou i++i
  if [ $i = 8 ]; then
    j=15
  fi
done

Boucler sur un répertoire

Nous allons maintenant voir comment parcourir un répertoire, cet opération est grandement utile lorsqu'on veut effectuer un certain traitement sur des fichiers: convertir, renommer, effacer... des fichiers.
FILES="/home/collinm/Musique/*.mp3"

for file in $FILES
do
  echo $file;
done

Si vous ne voulez pas employer de variable vous devez mettre le nom du répertoire entre `, ce qui donnerait

for file in `ls /home/collinm/Musique/*.mp3`
#le reste est identique...

Nous avons complété la partie traitant des boucles. Un script avec tous les exemples peut être téléchargé ici