Photographie/Fabricants/Canon/Canon PowerShot A530

Photographie/Fabricants/Canon/Canon PowerShot A540

Photographie/Fabricants/Nikon/Nikon Coolpix 700

Photographie/Fabricants/Olympus/Olympus C-2000 Zoom

Photographie/Fabricants/Toshiba/Toshiba PDR-M4

Photographie/Fabricants/Canon/Canon PowerShot A5 Zoom

Photographie/Fabricants/Ricoh/Ricoh RDC-5000

Photographie/Fabricants/Sony/Sony DSC-F55

Photographie/Fabricants/Olympus/Olympus FE-120

Algorithmique impérative/Pascal
Voici un guide de traduction d'un algorithme impératif en Pascal.
Le Squelette.
Pour le squelette de l'algorithme :
Algorithme mon_algo
Constantes
Types
Variables
Début
Fin
On traduit ainsi : 
program mon_programme;
Const
Type
Var
begin
end. (* notez ce point *)
Commentaires.
Les commentaires notés
 (* un commentaire *)
s'écrivent de la même façon
 (* un commentaire *)
Types.
Voici l'équivalence des types
Exemple sur ce dernier point : pour inclure une apostrophe dans une chaîne,
 writeln('l"apostrophe s"est échappée')
affiche 
 l'apostrophe s'est échappée
Constantes et variables.
Les constantes et les variables ont des identifiants qui doivent respectées une syntaxe précise.
les variables sont déclarées dans le Lexique du programme délimité par sa partie "Var". Chaque déclaration est de la forme
 identifiant : type;
Ainsi le lexique
 Lexique
 un_reel : réel (* un réel quelconque *)
 une_chaine : chaîne de caractères (* une chaîne quelconque *)
se traduit
Var
 un_reel : real; (* un réel quelconque *)
 une_chaine : string; (* une chaîne quelconque *)
Les accents ne sont généralement pas acceptés par les compilateurs Pascal.
Les identifiants des constantes respectent les mêmes règles. Par convention, on préférera les noter en majuscules. La déclaration d'une constante a pour syntaxe
 identifiant = valeur;
Ceci
 Constantes
 PI = 3,14
 G = 9,81
s'écrit en pascal :
Const
 PI = 3.14;
 G = 9.81;
Instructions et blocs d'instructions.
Pour exécuter une instruction (assignation, appel de fonction ou procédure) il suffit de l'écrire. Les paramètres sont précisés entre parenthèses et séparés par des virgules.
Les bloc d'instructions débutent par un codice_3 et se terminent par un codice_4. Les instructions du bloc sont séparées par des point-virgules. On gardera la convention algorithmique préférant une instruction par ligne.
Voici une ligne comportant une instruction unique :
 une_instruction
Voici un bloc de k d'instructions :
begin
 instruction_1;
 instruction_2;
 instruction_k
end
Remarquez qu'aucun point-virgule ne ponctue la dernière instruction. En effet le ';' est un séparateur : il sépare les instructions entre elles. Il n'y a donc pas de point-virgule après la dernière instruction, pas plus qu'il n'y en a avant la première. Cela explique également pourquoi lorsqu'on écrit une seule instruction, elle n'est pas suivie d'un point-virgule.
Il est souvent affirmé à tort que « toutes les instructions se terminent par un point-virgule ». Ce n'est pas tout à fait vrai, comme nous venons de le voir. Cependant, cette croyance répandue a été prise en considération par les développeurs des compilateurs qui ignorent cette erreur.
Il convient de remarquer que le programme principal est un bloc d'instructions ponctué d'un point, ni plus ni moins.
Lecture et Écriture (affichage).
L'affichage s'effectue à l'aide de la procédure codice_5. Elle peut prendre de un à plusieurs paramètres de n'importe quel type de base. Elle affiche tous les paramètres les uns après les autres (résultat identique à celui d'une concaténation).
Il existe une variante de codice_5 ayant la même spécification mais effectuant un retour à la ligne à la fin : il s'agit de la procédure </code>writeln</code>. On peut également appeler la procédure codice_7 sans préciser de paramètres, cela effectue un retour à la ligne.
La lecture se fait à l'aide de la fonction codice_8 qui prend en paramètre l'identifiant de la variable qui sera assignée.
codice_9 est indentique à codice_8 mais fait un retour à la ligne une fois la donnée lue.
Exemple
begin
 write('abc');
 write('def');
end
affiche 
 abcdef
alors que
begin
 writeln('abc');
 write('def');
end
affiche
 abc
 def
Assignation.
L'assignation est une instruction et à ce titre elle doit respecter les règles sur les instructions (points-virgules...)
L'opérateur d'assignation est := (et non = qui est le test d'égalité)
La syntaxe de l'assignation est (espaces facultatifs) :
identifiant := expression
Il va sans dire que le type de l'expression doit être compatible avec celui de la variable assignée.
Exécution conditionnelle.
On rappelle qu'une exécution conditionnelle est une instruction. Elle ne comporte pas de point-virgule sauf si elle est à l'intérieur d'un bloc. On suppose ici que l'instruction est au sein d'un bloc.
 si condition alors instruction
donne
if condition then instruction;
S'il y a plusieurs instructions, on utilise un bloc :
if condition then begin
 instruction_1;
 instruction_2;
 instruction_k;
end;
Avec une instruction à exécuter quand la condition est fausse (sinon) :
 si condition
 alors instruction_1
 sinon instruction_2
se traduit
if condtion
 then instruction_1
 else instruction_2;
De même on peut utiliser des blocs :
if condition then begin
 instruction_1;
 instruction_2;
 instruction_k;
end
else begin
 instruction_3;
 instruction_4;
 instruction_l;
end;
Structures itératives.
Une boucle à compteur
 POUR i de deb à fin faire instruction
donne
for i:=deb to fin do instruction;
On peut toujours utiliser un bloc comme instruction pour grouper plusieurs instructions à exécuter :
for i:=deb to fin do begin
 instruction_1;
 instruction_2;
 instruction_k;
end;
De même, une boucle répétée jusqu'à ce qu'une condition soit vraie (testée après chaque itération) :
repeat
 instruction
until condition;
et une boucle répétée tant qu'une condition est vraie (testée avant chaque itération) :
while condition do
 instruction
end;
Tableaux.
 lexique
 tab : tableau de deb à fin de T
donne :
var
 tab : array [deb..fin] of T;
Par exemple un tableau de 10 entiers, indicé de 1 à 10 :
var
 tab : array [1..10] of integer;
Le type enregistrement.
 type T = enregistrement
 champ : type_champ
 fin
donne
type T = record
 champ : type;
end;
Exemple :
type WikilivreInfo = record
 titre : string;
 nombre_de_pages : integer;
 en_vitrine : boolean;
end;

Photographie/Fabricants/Kodak/Kodak DC200 plus

Photographie/Fabricants/Kodak/Kodak DC240 Zoom

Photographie/Fabricants/Kodak/Kodak DC265

Hewlett-Packard
Photographie/Fabricants/Agfa/Agfa ePhoto CL50

Photographie/Fabricants/Agfa/Agfa ePhoto CL30

Photographie/Fabricants/Sony/Sony Mavica FD-88

Photographie/Fabricants/Sony/Sony Mavica FD-73

Photographie/Fabricants/Sony/Sony Mavica FD-83

Photographie/Fabricants/Olympus/Olympus C-2500 L

Photographie/Fabricants/Canon/Canon PowerShot A50

Photographie/Fabricants/Epson/Epson PhotoPC 800