intro_prog_linux.txt from Gulus at Krugle
Show intro_prog_linux.txt syntax highlighted
Introduction à la programmation sous Linux
Version 1.2 (2001/05/10)
Auteur: Mathieu Lutfy (mathieu@lowtech.dhs.org)
1.0 Introduction
================
1.1 Préambule
-------------
Ce texte vise à donner une introduction générale aux ressources disponibles
pour la programmation sous Linux. Ce texte prend pour acquis que le lecteur
est familier avec les bases de la programmation, que ce soit sous MS Windows
ou MacOS.
Vos commentaires ou corrections sont les bienvenues à mathieu@lowtech.dhs.org.
Vous pouvez retrouver la version originale et les versions futures de ce texte
à l'adresse suivante: http://mtl2600.dhs.org/textes/intro_prog_linux.txt
1.2 Redistribution
------------------
Vous pouvez librement redistribuer ce texte, en autant que vous respectez la
"GNU Free Documentation License":
Copyright (c) Mathieu Lutfy (mathieu@lowtech.dhs.org)
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation;
with no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts. A copy of the license is included in the section
entitled "GNU Free Documentation License".
1.3 Conventions utilisées dans ce texte
---------------------------------------
- Les références sont dans la dernière section du texte. Lorsqu'une de ces
références sera mentionnées dans le texte, il y aura un chiffre (ex: [1])
indiquant le numéro de la référence en question.
- Les sites web des applications mentionnées dans ce texte sont joints
aux références (à la fin du texte).
- Ce texte fait spécifiquement référence à Linux, mais la majorité des
pricipes s'appliquent à Unix en général (FreeBSD, OpenBSD, SunOS/Solaris,
etc..).
- Lorsque utilisé en début de ligne, $ représente l'invite de la ligne de
commande (prompt).
1.4 Pourquoi programmer sous Linux ou Unix?
-------------------------------------------
Linux est un système d'exploitation multi-plateforme (IA32, IA64, PowerPC,
Alpha, Sparc, etc..) à la fois flexible, stable et performant. De plus, Linux
a été construit avec la même philosophie qu'Unix et il existe un standard
de programmation nommé POSIX (Portable Operating System Standart) qui permet
aux programmeurs de garder un niveau d'abstraction suffisamment élevé face
au système d'exploitation.
Le plus grand avantage découle probablement du fait que la philosophie
dominante des usagers de Linux est celle du Logiciel Libre (Free Software).
L'usager est donc libre d'adapter un programme à ses besoins, libre de
participer au développement du logiciel et libre de copier le code source
d'une application dans son application, en autant que les deux applications
soient considérées des Logiciels Libres.
Un texte incontournable sur le sujet est "The Art of Unix Programming"[1],
par Eric S. Raymond.
1.5 La guerre des éditeurs
--------------------------
Une bonne partie de ce document est consacrée aux éditeurs pour programmer.
La raison est très simple, sous Linux, les gens sont généralement d'accord
pour dire que GNU gcc est le meilleur compilateur, GNU gdb un excellent
débogueur, etc.. mais étant donné que les usagers passent la majorité de
leur temps à programmer dans un éditeur de texte, ils tendent à être très
pointilleux sur le comportement de ce dernier.
De plus, il y a deux types d'éditeurs: les IDE (Integrated Development
Environment) et les programmes qui ne sont qu'un éditeur de texte. Les usagers
de MS Windows sont probablement familiers avec l'IDE "MS Visual C++", et
les éditeurs "simples" tels que Notepad ou Ultra Edit.
De façon générale, les IDE ont une interface graphique au compilateur et
au débogueur, tandis que l'éditeur ne fait qu'éditer et a une interaction
limitée avec le compilateur et le débogueur (c'est le cas pour tous les
éditeurs mentionnés dans cet article).
Sous Linux, il n'y a pas un éditeur prédominant. Vi/Vim, Emacs, Code Crusador,
KDevelop, NEdit, jEdit, etc.. ne sont que le début de la liste. De plus, le
débat cherchant à définir "le meileur éditeur" est toujours d'actualité. À
chaque année, des partisans de Vi et Emacs (deux vétérans dans le domaine de
la programmation) se réunissent pour s'affronter dans une partie de "paintball".
2.0 Survol des éditeurs graphiques
==================================
2.1 Note
--------
Trois points communs sont dans les sections ci-bas: sous-applications
supportées, langages/syntaxes supportés et licence. J'ai eu de la difficulté
à choisir une expression qui s'appliquait à tous les éditeurs concernant
les deux premières sections. Je m'explique:
- Sous-applications supportées:
La majorité des IDE n'ont pas de compilateur ou débogueur intégré (tel
qu'expliqué dans la section 1.5), mais auront une interface graphique pour
simplifier la sortie texte des applications appelées, donnant l'impression
que le compilateur est intégré. Une sous-application qui n'est pas listée
signifie que pour l'exécuter, il faudra lancer la commande par un terminal.
Beaucoup d'éditeurs font cela parce que leurs usagers préfèrent utiliser
ces outils de la façon traditionnelle (et standard) plutôt que d'avoir une
interface différente pour chaque éditeur.
- Langages/syntaxes supportés:
Ceci signifie que l'éditeur est capable de surligner et indenter le code.
Si votre langage préféré n'est pas listé, cela signifie que l'éditeur
agira comme un éditeur de texte ordinaire (à-la-Notepad), mais certaines
fonctionalités seront quand même configurables.
- Licence:
Tous les logiciels dans ce texte sont des Logiciels Libres, c'est à dire
que vous avez accès à leur code source et leur utilisation n'est pas limitée.
Vous trouverez plus d'information sur les différentes licences "Libres"
sur le site de GNU[2] et OpenSource[3] (ils ont des mentalitées divergentes,
mais pour vous l'usager, ils sont équivalents).
2.2 Code Crusader
-----------------
Inspiré par l'interface graphique de Metrowerks Code Warrior, Code Crusador
est probablement un des éditeurs qui inclue le plus d'outils graphiques pour
programmer, dont un débogueur graphique (Code Medic), un générateur de
graphique pour illustrer graphiquement l'héritage des classes C++ et génère
automatique les fichiers Makefile (pour automatiser la compilation), en plus
des fonctionalités habituelles, soient la vérification et colorisation du
code source, etc..
Le seul défaut à cette application pourrait être un peu irritant. L'application
a été écrite avec un API graphique nommé "JX Application Framework", dont
l'apparence est loin d'être aussi attrayante que celles de GTK+/Gnome ou
QT/KDE. Par contre, l'application est très rapide et ne consomme pas beaucoup
de mémoire vive.
- Sous-applications supportées:
Fortran, bison, cc, CC, flex, gcc, g++, g77, KAI C++, make
- Langages/syntaxes supportés:
C, C++, HTML (voir leur site web pour plus d'informations, beaucoup d'autres
langages sont partiellement supportés)
- Licence:
New Planet Software Library Open Source License Version 1.0 (basée sur QPL)
2.3 KDevelop
------------
Fortement inspiré de Microsoft Visual C++, KDevelop mise sur la facilité
d'utilisation et outils d'aide à la programmation. Parmis ses points forts
sont le support des projets QT/KDE et GTK+/Gnome, un navigateur visuel de
classes (C++), une interface à CVS (Control Version System) et un assistant
de projets (app wizard + générateur de fichiers autoconf/automake).
Leur site web contient une impressionnante quantité d'information, tutoriels,
forum de discussion, etc. Chose rare pour un éditeur de programmation.
Petit inconvénient, l'éditeur comprend que les langages C et C++.
- Sous-applications supportées: autoconf, automake, make, gcc, g++
- Langages/syntaxes supportés: C, C++
- Licence: GNU GPL
2.4 jEdit
---------
jEdit se veut simple, flexible et pratique. Plus de 40 langages sont
supportés, indentation automatique, vérification de syntaxe et transferts
FTP intégrés (donne l'impression d'éditer un fichier à distance) ne sont
que quelques fonctionalités, mais son architecture modulaire très flexible
est très intéressante. Lancez le gestionnaire de "plugins" lorsque vous
êtes connectés à Internet et celui-ci ira chercher la liste des plugins
disponibles et les téléchargera au besoin. De plus, le navigateur de
classes rend la programmation Java et C++ plus agréable.
L'application est écrite en Java, ce qui, comme toutes applications Java,
est un avantage et un inconvénient. D'une part, il est un peu plus lent
et un peu gourmand, mais en revanche, vous pourrez l'utiliser sur toutes
les plateformes supportées par Java (Unix, MacOS, Windows, etc..).
- Sous-applications supportées: Aucune, mais des plugins supportent le Java
- Langages/syntaxes supportés: Java, C, C++, Perl et plus de 40 autres
- Licence: GNU GPL
2.5 NEdit
---------
NEdit est petit et facile à configurer. Son apparence est très minimaliste,
mais il peut surligner du code, faire des macros et beaucoup plus que les
autres éditeurs de cette catégorie. Toutefois, il ne gère pas les projets
et il n'a pas d'interface graphique à la compilation.
- Sous-applications supportées: aucune
- Langages/syntaxes supportés: Ada, C, C++, Fortran, Java, Perl, Python
et beaucoup d'autres
- Licence: GNU GPL
3.0 Survol des éditeurs traditionnels
=====================================
3.1 Introduction
----------------
Les deux principaux éditeurs traditionnels sont Vi et Emacs. Connus par
certains comme étant inutilement complexes, mais aussi connus pour leur
flexibilité et efficacité.
3.1 Emacs / XEmacs
------------------
Emacs contient beaucoup trop d'outils et de commandes pour en faire un
survol dans ce texte. Par contre, c'est facile de se promener dans
l'éditeur avec les quelques commandes suivantes:
(Note: Ctrl est représenté par "C" et la virgule "," devrait se lire "puis")
C-x, C-f : Ouvrir un fichier (la touche Tab peut être utilisée pour compléter
ou lister les choix disponibles)
C-x, C-s : Sauver un fichier
C-s : (search) Faire une recherche dans le texte
C-g : Annuler la commande en cours
C-x u : (undo) Annuler la dernière commande
C-x 2 : Créer une nouvelle fenêtre horizontalement
C-x 3 : Créer une nouvelle fenêtre verticalement
C-x 1 : Cacher les autres fenêtres et affiche que la fenêtre active
C-x o : Se déplacer d'une fenêtre à l'autre (comme Alt-Tab dans Windows)
C-x k : (kill) Fermer le texte de la fenêtre active
C-espace : Commencer la sélection d'une région (puis se déplacer avec les
flèches pour sélectionner une région)
Alt-w : Copier la région sélectionnée
C-w : Couper la région sélectionnée
C-y : Coller la région copiée
C-x, C-c : Quitter emacs
XEmacs est un clône d'Emacs, mais avec une interface graphique plus facile
à utiliser. Toutefois, les dialogues de sélections d'XEmacs ont un défaut,
pour sélectionner il faut utiliser le bouton du milieu de votre souris et
non le bouton gauche (si vous n'avez que deux boutons, il faut cliquer les
deux en même temps pour simuler le 3e bouton).
3.2 Vi / Vim / gVim
-------------------
Vi est un éditeur très minimaliste, mais extrêmement puissant. Avec le temps,
Vim (Vi iMproved) est venu remplacer Vi et est beaucoup plus convivial. Il
comprend aussi une interface graphique (optionnelle), gVim, qui a l'apparence
du Notepad dans Windows, mais avec ayant quand mêmes les commandes de
réputations obscures de Vi.
Les avantages de Vim par rapport à Vi sont nombreux. Pour en nommer quelques
uns, Vim permet de surligner la syntaxe, plusieurs niveaux de "undo" (et
"redo") et permet d'afficher plusieurs fichiers dans le même cadre (surtout
pratique pour le mode texte).
Voici quelques commandes essentielles à Vi:
:e foo.c : ouvre un fichier (ou le crée)
:w : sauver le fichier
:w bar.c : sauver le fichier sous le nom bar.c
:q : quitter vi (ou fermer la fenêtre active)
:q! : quitter vi sans sauver
i : insérer avant le curseur (I : insérer au début de la ligne)
a : insérer après le curseur (A : insérer à la fin de la ligne)
o : ouvrir une ligne en-dessous (O : ouvrir une ligne au-dessus)
J : joindre la ligne suivante après la ligne courante
u : undo (annuler la dernière commande)
U : undo global pour toute la ligne
Ctrl+R : redo (annuler la dernière commande annulée)
Ctrl+G : Affiche des informations sur le fichier et la position du curseur
ESC : quitter le mode d'insertion
Chercher et remplacer:
:n : Aller à la n-ième ligne. (:1 aller au début du texte)
/foo : Recherche le mot "foo" dans le texte (?foo cherche en arrière)
:s/ab/ba : Substituer la première occurence de "ab" par "ba"
Pour remplacer toutes les occurences sur la ligne, :s/ab/ba/g
(où 'g' signifie 'global')
:4,10s/ab/ba/g : Remplace toutes les occurences de "ab" par "ba" sur les lignes
de 4 à 10. (:1,$s/ab/ba/g pour tout le texte, $ = fin)
%s/ab/ba : Remplacer toutes les occurences.
Couper/Coller, supprimer:
x : Coupe le caractère sous le curseur (10x en supprime 10)
dd : Coupe la ligne courante (10dd en supprime 10)
D : Coupe à partir du curseur jusqu'à la fin de la ligne courante
yy : Copie la ligne courante
Y : Copie à partir du curseur jusqu'à la fin de la ligne courante
p : Colle (paste) la dernière chaine de texte coupée/copiée
:1,4y : Copie les lignes 1 à 5 (ce genre de préfixe s'applique à toutes les
commandes)
Se promener dans plusieurs fenêtres (spécifique à vim) :
:new foo : Ouvrir une nouvelle fenêtre et lire le fichier "foo"
Ctrl+w : Changer de fenêtre. Faire deux fois pour aller à la prochaine,
ou faire Ctrl+w+flèche_haut pour aller à la fenêtre du haut.
Les préfixes de lignes tels que "1,30" (qui signifie "de la ligne 1 à 30")
s'appliquent à la majorité des commandes qui commencent par ":".
Sous Vim, il est aussi possible d'activer la vérification et la colorisation
de la syntaxe avec ":syntax on" (pour automatiser cette commande, il suffit
de l'ajouter dans le fichier "~/.vimrc" avec la commande:
$ echo "syntax on" >> ~/.vimrc
Bref, les commandes de Vi sont très excentriques, mais par la quantité de
combinaisons possibles, Vi devient un outil très efficace.
4.0 Compiler
============
4.1 GNU gcc
-----------
Généralement appelé gcc pour le "Gnu C Compiler", gcc peut aussi compiler
du C++ (g++), Java (gcj), Assembleur AT&T (gas), Fortran (g77) et autres.
Si vous utilisez un IDE, vous n'aurez pas vraiment à vous soucier de cette
section, mais c'est quand même utile de savoir comment les outils que vous
ne voyez pas fonctionnent, ça peut faciliter le déboguage et mieux comprendre
le processus global de la programmation. C'est aussi pratique de connaître
ces outils si vous travaillez par telnet où vous ne pourrez pas utiliser
votre IDE préféré.
Voici quelques exemples de compilation d'applications, du plus simple vers
des exemples plus complexes:
$ g++ foo.cxx
Par défaut le compilateur nomme l'exécutable "a.out", ajoutons l'options
-o pour spécifier le nom du fichier à la sortie:
$ g++ foo.cxx -o toto
Si nous avons plusieurs fichiers sources pour le même exécutable:
$ g++ foo.cxx bar.cxx -o toto
L'usage de -Wall est très fortement suggéré pour éviter les erreurs de
syntaxe et afficher le maximum d'avertissements:
$ g++ -Wall foo.cxx -o toto
Lorsque l'on doit déboguer avec gdb, on peut savoir exactement à quelle
ligne de code le programme a planté, et quelles étaient les variables en
ajoutant l'option -g:
$ g++ -Wall -g foo.cxx -o toto
Vous pouvez aussi demander à gcc d'optimiser le code machine généré, mais
étant donné que ça demande plus de temps pour compiler, il est suggéré
d'utiliser cette option que lorsque vous faites la commpilation finale de
votre programme. Ceci se fait par l'option -O{1,2,3}:
$ g++ -Wall -O1 foo.cxx toto
Pour exécuter l'application, il suffit de faire "./toto". Le "./" signifie
que l'on veut exécuter une application qui se situe dans le répertoire
courant.
Nous verrons dans la prochaine section comment automatiser la compilation
d'une application.
4.2 GNU make
------------
Make est un outil qui permet de simplifier et accélérer la compilation d'une
application. Pour ce faire, l'application cherche un fichier "Makefile" qui
indique comment compiler l'application. Tout comme GCC, make est souvent
facilité par les IDE.
Voici un exemple de Makefile:
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Makefile .
OBJS = fichier1.o fichier2.o
EXEC = toto # nom exécutable de l'application
CC = g++ # nom du compilateur, aurait pû être gcc, gcj, etc..
CFLAGS = -Wall -g # voir le "man page" de gcc pour la liste complète
DEL = rm -f # peut varier d'un système d'exploitation à l'autre
all : $(OBJS)
$(CC) $(OBJS) -o $(EXEC)
# les fichiers à compiler :
fichier1.o : fichier1.cxx fichier1.h
$(CC) $(CFLAGS) -c fichier1.cxx -o fichier1.o
fichier2.o : fichier2.cxx fichier2.h
$(CC) $(CFLAGS) -c fichier2.cxx -o fichier2.o
# petite fonction pour faire le ménage des exécutables:
clean :
$(DEL) $(EXEC) $(OBJS) core
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fin . .
Maintenant, faire
$ make
Compilera notre application, car "make" sans paramètre exécute la première
section qu'il trouve, soit "all" (ceci est une convention), puis
$ make clean
supprimera les fichiers exécutables et "objects" (.o).
Make est un bon outil pour les petits projets de 2 à 10 fichiers source,
mais ça peut facilement devenir encombrant lorsqu'il y a des dépendances
externes. Il y a de nombreux programmes pour simplifier la gestion d'un
Makefile tels que la combinaison de autoconf[2] et automake[3].
5.0 Déboguer
============
5.1 GNU gdb
-----------
Gdb est le "Gnu Debugger". Il peut être particulièrement efficace pour
déboguer des applications multi-thread ou des programmes extrêment complexes,
mais puisqu'il faut limiter la taille de cet article, il y a principalement
deux commandes à connaître pour gdb:
Si notre programme toto plante:
$ ./toto
segmentation fault
Pas très descriptif...
$ gdb toto
GNU gdb 5.0
[snip, information sur gdb]
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) run
Program received signal SIGFPE, Arithmetic exception.
0x804883f in main (argc=1, argv=0xbffffa24) at main.cxx:27
27 int foo = 5 / 0;
Ce qui nous permet de voir qu'à la ligne 27 de main.cxx, il y a une division
par zéro.
Cet exemple était peut-être un peu trop facile, prenons un exemple plus
obscur qui se produit souvent en C++:
$ gdb toto
GNU gdb 5.0
[snip, information sur gdb]
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) run
Program received signal SIGSEGV, Segmentation fault.
0x400f501d in free () from /lib/libc.so.6
Le programme a buggé dans une fonction qui est dans la librairie C (une
librairie de très bas niveau qui est appelée par des appels intermédiaires
dans une application, mais c'est probablement la fonction qui a fait cet
appel qui est la source du problème. Pour voir par où le programme a passé
avant de planter, utiliser la commande "bt", soit "backtrace", qui permet
de tracer l'exécution:
(gdb) bt
#0 0x400f501d in free () from /lib/libc.so.6
#1 0x40048814 in __builtin_delete () from /usr/lib/libstdc++-libc6.2-2.so.3
#2 0x8048a94 in Pile<int>::depiler (this=0xbffff9b8, valeur=@0xbffff948) at pile.cxx:88
#3 0x8048b01 in Pile<int>::vider (this=0xbffff9b8) at pile.cxx:114
#4 0x8048b4b in Pile<int>::~Pile (this=0xbffff9b8, __in_chrg=2) at pile.cxx:32
#5 0x8048947 in main (argc=1, argv=0xbffffa24) at main.cxx:43
#6 0x400a1bcc in __libc_start_main () from /lib/libc.so.6
La réponse n'est peut-être pas aussi évidente que l'exemple précédent, mais
au moins nous pouvons voir qu'à la ligne #1 qu'il y a eu un problème lors de
la désallocation de l'objet, d'où l'erreur fréquente en C ou C++ d'accéder à
un espace mémoire du système qui n'appartient pas.
5.2 lclint
----------
Lclint vérifie la solidité d'applications écrites en C et permet de trouver
plusieurs erreurs de sémantique et autres erreurs fréquentes. Toutefois, lclint
analyse que le C.
6.0 Migrer de Windows vers Linux/Unix
=====================================
Cette section traite brièvement des erreurs communes lors de la migration d'un
programme de Windows vers Unix.
6.1 Transfers de fichier
------------------------
Le code source d'un programme est généralement sauvegardé dans un fichier en
texte pur (contrairement à Microsoft Word qui stock ses fichiers dans un format
propriétaire et binaire, illisible sans le logiciel en question), toutefois, le
format texte varie selon la plateforme.
Si vous transférez un fichier texte de Windows vers Linux et que vous ouvrez
le fichier à l'aide de (par exemple) l'éditeur Vi, vous verrez des caractères
"^M" à la fin de chaque ligne. Ceci est causé par le fait que Microsoft Windows
(héritage du DOS) termine chaque ligne par les caractères "\n\r", tandis que
Unix termine chaque ligne uniquement par "\n".
Ces caractères ne dérangent pas la majorité des compilateurs (ex: gcc
n'émettera aucun avertissement), mais si vous continuez l'édition du programme
sous Unix, il existe plusieurs solutions pour les enlever:
- Transférer par FTP en mode "Ascii" (le mode par défaut est "Binaire").
Pratique pour un seul fichier, mais trop long pour un programme complet ou
un programme stocké dans une archive compressée. (éviter de transférer un
fichier binaire en mode Ascii)
- Utiliser un éditeur tel que Vim qui peut travailler avec des fichiers en
format Windows ou MacOS sans avoir à convertir le fichier. Vim peut aussi
convertir les fichiers à l'aide de la commande:
:set ff=unix (ff = file format; autre format: mac, dos)
- L'utilitaire "dos2unix" est disponible sur beaucoup de systèmes Unix (avec
son inverse "unix2dos"), il suffit d'exécuter la commande:
$ dos2unix mon_fichier.c
$ dos2unix *.c (tout les fichiers)
- Perl: perl -p -i.old -e 's/\r/\n/g' [fichiers]
6.2 Votre code est-il vraiment multi-plateforme?
------------------------------------------------
Certains compilateurs ou interpréteurs sont parfois trop vieux. Votre code
peut fonctionner sur le compilateur en question, mais causera plusieurs erreurs
ailleurs, dont:
- Erreurs de syntaxe
C'est le cas du vieillissant, mais vénéré compilateur C/C++ de Borland (3.x?)
qui roule sous Microsoft DOS 6.x. Le compilateur est loin d'être compatible à la
norme ANSI/ISO C++ et accepte de nombreuses erreurs de syntaxe. Par exemple, il
accepte "#include <iostream.h>;" (avec un ";" à la fin de la ligne, erreur
subtile et commune au près des apprentis programmeurs C/C++). Le compilateur
GNU G++ donnera l'erreur suivante:
prog.cc:1: `#include' expects "FILENAME" or <FILENAME>
Aucune référence au ";" de trop. Petite erreur qui risque de vous faire
perdre beaucoup de temps!
- conio.h [C/C++]
Certains usagers incluent ce fichier pour effacer l'écran ou inclure de la
couleur dans les sorties texte. Ceci n'est pas ANSI/ISO et fonctionne que sous
DOS. Pour effacer l'écran sous Unix, faites:
#include <stdlib.h>
system("clear");
Cette commande exécutera la commande shell "clear".
- Errers de sémantique et comportements indéfinis:
Plusieurs langages (Lisp, C, C++ surtout) ont des opérations qui n'ont pas de
comportement défini ou ont un comportement aproximatif. Le simple fait de
changer de compilateur/interpréteur, de système d'exploitation (Win -> Unix ->
Linux -> Mac) ou d'architecture (Intel -> Sparc -> PowerPC) peut fausser les
résultats d'une application.
À ma connaissance, aucun compilateur détecte ce genre d'erreurs. Voici un
exemple d'erreur:
float a = 2;
float b = 1;
a /= 3;
b /= 3;
if(a/3 == b/3 * 2)
arreter_reacteur_nucleaire();
Même si la syntaxe est correcte, la condition ne sera jamais atteinte. Soyez
sûr de bien connaître le langage et l'architecture avec lesquels vous
programmez et ne vous contentez pas du simple fait que le programme compile.
- Librairies, APIs et extentions spécifiques à une plateforme:
Si vous avez une application avec des "DLL", ces derniers devront être
convertis (shared libraries). Si vous n'avez pas leur code source ou s'ils
sont étroitement reliés au système d'exploitation, vous devrez trouver des
alternatives. Desfois il est possible de porter une application à l'aide de
l'API "Wine" (Wine Is Not an Emulator) qui est une implémentation Libre de
l'API win32 et (partiellement?) DirectX/Direct3D. Toutefois, ceci déborde le
contexte de ce document. Voir la section 8 (Références) pour des liens.
7.0 Conclusion
==============
N'oubliez pas que chaque application possède une courbe d'apprentissage. Il y
a généralement deux catégories: soit l'apprentissage est difficile au début,
mais l'application est très flexible et efficace (courbe de la fonction
exponentielle), tandis que d'autres sont très faciles dès le début, mais les
fonctionalités plus avancées sont soit inexistantes ou inutilement complexes
(courbe de la fonction racine carrée).
Sous Linux (et Unix en général) vous avez le choix entre une multitude
d'applications, il suffit de faire une bonne combinaison de logiciels pour
ainsi combiner les deux courbes à votre avantage.
8.0 Références
==============
8.1 Général
-----------
Linux : http://www.linux.org/, http://www.linux.com/
FreeBSD : http://www.freebsd.org/
OpenBSD : http://www.openbsd.org/
NetBSD : http://www.netbsd.org/
Gnome : http://www.gnome.org/
KDE : http://www.kde.org/
8.2 Éditeurs
------------
Code Crusader : http://www.newplanetsoftware.com/
KDevelop : http://www.kdevelop.org/
jEdit : http://jedit.sourceforge.net/
NEdit : http://nedit.org/
Emacs : http://www.gnu.org/software/emacs/emacs.html
XEmacs : http://www.xemacs.org/
Vim/gVim : http://www.vim.org/
8.3 Autres
----------
GCC : http://www.gnu.org/software/gcc/gcc.html
GJC : http://sources.redhat.com/java/
lclint : http://lclint.cs.virginia.edu/
Wine : http://www.winehq.com/
8.4 Sites mentionnés dans ce texte
----------------------------------
1 - The Art of Unix Programming: http://www.tuxedo.org/~esr/writing/taoup/
2 - GNU : http://www.gnu.org/
3 - OpenSource : http://www.opensource.org/
8.5 Sites complémentaires
-------------------------
- Cartes de références (gdb, emacs et autres): http://www.refcards.com/
- Répertoire d'applications Linux: http://freshmeat.net/
- Répertoire d'applications scientifiques: http://sal.kachinatech.com/index.shtml
9.0 Remerciements
=================
Je tiens à remercier les personnes suivantes dont les contributions sont
grandement appréciées.
Vincent Labrecque (limitln at cooptel.qc.ca)
Benoit des Ligneris (benoit.des.ligneris at physique.usherb.ca)
Guillaume Pratte (pratg00 at dmi.usherb.ca)
Sébastien Nadeau (nades00 at dmi.usherb.ca)
See more files for this project here