Conception centré sur l’usager.

(Résumé des notes de cours de Sébastien Roy)

Utiliser le modèle en spirale:

• les premières itérations doivent couter le moins chère possible, pour cela au départ il faut utiliser des prototypes simple fait sur papier (ex : sketch), le prototype papier est facile a faire et a modifier en plus de cela il est possible d’en faire plusieurs (maquettes).
• Faire le plus d’itérations possible et faire une évaluation de chaque itération par l’utilisateur.
• Focus sur l’usager : mieux le connaître, ce qu’il fait, le faire intervenir à chaque itération surtout utiliser de vrais usagers pour faire les testes. Pour cela il faut établir des questionnaires, faire des interviews et émettre des observations.
• Comprendre les besoins de l’usager : ce qu’il veut faire et non comment il le fait (use cases).

Important :

1. Faire intervenir le client à chaque étape du développement.
2. regarder pourquoi un usager fait ce qu’il fait, plutôt que seulement ce qu’il fait.
3. Eviter de refaire les choses de la mauvaise façon.

make et Makefile

Pour faire simple, make est un programme permettant la gestion de la compilation, il prend comme entrée un fichier du nom Makefile et exécute les instructions de ce dernier pour générer le programme.

Exemple de Makefile simple…très simple :

hello : prog.c
	gcc prog.c -o hello

pour construire le programme hello il faut exécuter : $ make

Le principe :

cible : prés-requis
	commandes pour créer la cible

correspondance avec notre exemple :

cible : hello
prés-requis : proc.c
commandes : gcc prog.c -o hello

donc pour créer le programme hello, il nous faut le fichier prog.c, il faut exécuter la commande

$ gcc prog.c -o hello

Exemple plus réel:
Supposons que pour créer le programme principale prog il nous faut les librairies lib1 et lib2. Pour la librairie lib1 il faut compiler le fichier lib1.c et pour lib2 il faut compiler lib2.c, le Makefile deviens :

prog : prog.o lib1.o lib2.o
	gcc -o prog prog.o lib1.o lib2.o

prog.o : prog.c prog.h
	gcc -c -o prog.o prog.c 

lib1.o : lib1.c lib1.h
	gcc -c -o lib1.o lib1.c

lib2.o : lib2.c lib2.h
	gcc -c -o lib2.o lib2.c

Le meilleur:
après chaque modification de fichier du projet, make exécute les commandes que pour les fichier modifiés.

Premiers pas avec GCC

Gcc ou GNU Compiler Collection est un compilateur et un ensemble d’outils permettant la construction de programmes. GCC s’exécute sur différentes architectures et différents systèmes et permet la création de binaire pour différentes architectures. Il supporte également plusieurs langages notament C, C++, Objective-C, Java, Fortran, Ada…
Voila pour la présentation, pour le moment ce qui m’intéresse est le compilateur C.

La compilation d’un programme écrit en langage C passe par plusieurs étapes :

• Preprocessing : gcc -E prog.c -o prog.i
• Compilation : gcc -S prog.i -o test.s
• Assemblage : gcc -c prog.s -o prog.o
• Édition de lien : gcc prog.o -o prog

La manière simple de compiler un seul fichier est :

$ gcc prog.c -o prog

le résultat est le programme exécutable prog.

$ gcc -c prog.c donne comme résultat le fichier objet prog.o

pour la compilation de plusieurs fichiers :

$ gcc -o prog p1.c p2.c

En pratique il est très important d’activer les messages de warning afin de découvrir des la compilation les problèmes potentiel du programme.

$ gcc -Wall prog.c -o prog

Pour pouvoir déboguer le programme il faut le compiler avec -g :

$ gcc -g prog.c -o prog