-
Notifications
You must be signed in to change notification settings - Fork 2
/
ide.tex
203 lines (134 loc) · 15.6 KB
/
ide.tex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
\documentclass[a4paper, 12pt]{article}
\usepackage [frenchb]{babel}
\usepackage{color}
\usepackage[utf8]{inputenc}
\usepackage[top=3cm, bottom=4cm, left=3cm, right=3cm]{geometry}
\usepackage{setspace}
\usepackage[pdftex]{graphicx}
\newcommand{\HRule}{\rule{\linewidth}{0.5mm}}
\begin{document}
\definecolor{bleuciel}{RGB}{168,248,248}
\definecolor{blanc}{RGB}{255,255,255}
\pagecolor{bleuciel}
\begin{titlepage}
\begin{center}
\includegraphics[width=0.15\textwidth]{./images/logo.png}~\\[1cm]
\textsc{\LARGE Prep'ISIMA}\\[1.5cm]
\textsc{\Large Rapport de Génie Logiciel}\\[0.5cm]
\HRule \\[0.4cm]
{ \huge \bfseries IDE : Integrated Development Environment}\\[0.4cm]
\HRule \\[1.5cm]
\begin{minipage}{0.4\textwidth}
\begin{flushleft} \large
\emph{Auteurs :}\\
Benoît \textsc{Garçon}\\
Loïck \textsc{Chiron}\\
Marie \textsc{Cassaing}
\end{flushleft}
\end{minipage}
\begin{minipage}{0.4\textwidth}
\begin{flushright} \large
\emph{Enseignant :} \\
Jonathan \textsc{Passerat-Palmbach}
\end{flushright}
\end{minipage}
\vfill
{\large \today}
\end{center}
\end{titlepage}
\setcounter{page}{1}
\newpage \renewcommand{\contentsname}{Sommaire} \tableofcontents
\pagecolor{blanc}
\newpage \section*{\underline{Introduction}} \addcontentsline{toc}{section}{Introduction}
\begin{doublespace}
Il existe aujourd'hui une multitude de façons de produire du code et par extension un programme. Elles sont plus ou moins conseillées selon le support, le langage de programmation et surtout l'utilisateur. De façon générale, tout ce qui nous est proposé reflète une qualité certaine et un avantage non négligeable pour le programmeur si toutefois les bonnes pratiques de programmation sont respectées.
C'est donc pour facilité la vie des programmeurs et surtout pour pallier leur oisiveté qu'ont été créés les Environnements de Développement Intégré ( EDI ) ou encore integrated development environment ( IDE ) en anglais. En effet, au début de l'ère informatique, le développement ne nécessitait pas autant de fichiers et autres car l'on utilisait des cartes perforées. C'est donc avec l'apparition de la programmation générique actuelle que sont apparus les EDI. La première étape était Dartmouth BASIC en 1964. Ce fut le premier langage dit "intéractif". Ensuite en 1975, vint Maestro I qui est aujourd'hui considéré comme le père fondateurs des IDE. On notera aussi l'apparition de Softbench en 1995 qui a démocratisé les IDE à plug-in.
Un EDI est donc un programme regroupant de multiples sous programmes, facilitant la production et la mise en œuvre de code. Mais alors, comment un IDE peut-il assister un programmeur ?
Nous verrons donc qu'il existe tout une liste de fonctionnalités qui font d'un IDE une solution de développement intéressante puis nous concentrerons notre attention sur l'exemple de CodeBlocks.
\end{doublespace}
\newpage \section{\underline{IDE : un éventail de fonctionnalités en un programme}}
\begin{doublespace}
\subsection{Les fonctionnalités basiques}
Un environnement de développement comporte tous les outils nécessaires pour analyser, écrire et debugger votre programme. Il comporte une jolie interface graphique permettant une utilisation simple de tous les outils qu’il met à votre disposition. On retrouvera donc dans tous les IDE, des éléments incontournables tels qu’un éditeur de texte incorporé comportant une syntaxe typique. C’est-à-dire une mise en valeur de votre code par l'intermédiaire d'une indentation automatique, de mise en couleur des mots clés et d'une complétion automatique de ces mots clés. Il y aura également dans la plupart des cas un débuggeur et un compilateur de manière à pouvoir rédiger, corriger et tester votre programme avec un seul logiciel. De manière générale, le processus de débogage commence pendant la génération. La génération de votre programme aide à détecter les erreurs de compilation et vous affiche les numéros de lignes correspondants. Les erreurs les plus fréquentes étant dues à une syntaxe incorrecte, à des mots clés mal orthographiés ou à une incompatibilité de type. Enfin, un IDE est également très souvent muni d’un système de gestion de projet très pratique lorsque l’on va réaliser un programme de manière collaboratif au sein d’une entreprise par exemple. Cela regroupe donc l’interconnexion des données, dossiers et fichiers nécessaires à la réalisation du projet.
\newpage \subsection{Les fonctionnalités avancées}
Certains EDI plus perfectionnés vont être dotés d’autres fonctionnalités : on trouvera par exemple un outil de création d’interface graphique. Cela permet, comme son nom l’indique, d’aider le programmeur lors de la réalisation de l’interface graphique de son programme. Un EDI peut également comporter un moteur de recherche intégré tenant compte du langage de programmation que vous utilisez, cela vous permet d’effectuer (de manière rapide et efficace) une recherche sur une fonction ou une syntaxe qui pourrait poser problème. Certains environnements sont munis d’un générateur de documentation ou intègre un générateur existant comme Javadoc, Doxygen ou bien Scaladoc. Ceci est très pratique lorsque vous réaliser un programme avec d’autres personnes, car avec la documentation, chacun peut comprendre la signification de vos fonctions et autres boucles qui peuvent paraître étranges à première vue. Enfin, on trouvera un gestionnaire de version ou là aussi l’intégration d’un gestionnaire de version comme Subversion, CVS ou Git permettant de conserver toutes les étapes de la réalisation de votre programme en utilisant des versions antérieures à votre fichier actuel.
\end{doublespace}
\newpage \section{\underline{CodeBlocks : un exemple d'application}}
\begin{onehalfspacing}
\subsection{Un premier aperçu}
Nous avons choisis ici de vous présenter un IDE particulier puisqu'il est connu par la majorité des membres du groupe : il s'agit Code::Blocks qui fait parti des IDE les plus répandus pour les langages C et C++ (aussi utile pour le Fortran et le D). Voici donc un outil privilégié pour les développeurs en herbe et peut-être même les plus confirmés. Les raisons d'un tel succès sont assez simple :
\begin{itemize}
\item libre et " open source " : c'est un logiciel gratuit donc accessible à tous mais aussi perfectible par tous
\item multiplateforme : que l'on développe sous Linux, Mac OS X ou même Windows il existe une version disponible
\item complet : Code::Blocks offre une multitude de fonctionnalités pratiques que l'on peut attendre d'un bon IDE, mais s'il manque un outil il y aura certainement un plug-in pour pallier ce défaut.
\end{itemize}
L'aventure Code::Blocks commença en 2005, il a été développé en C++ grâce à la bibliothèque wxWidgets, ce qui explique pourquoi il est si simple d'améliorer cet IDE. Code::Blocks est un logiciel assez intuitif et simple d'utilisation (mais il reste toutefois très complet). Bien qu'utilisable en ligne de commande, il arbore aussi une interface graphique très classique. On retrouve en haut de la fenêtre les différents menus et boutons donnant accès à toutes les fonctionnalités. Le reste est divisé en deux zones : \begin{itemize}
\item la zone centrale étant composé de l'indispensable éditeur de texte pour taper le code associé à un explorateur de fichiers
\item la console de sortie au bas de l'écran regroupe les différents résultats des opérations effectuées et les classe par catégories : recherche, debugger, compilateur …
\end{itemize}
[Voir la Figure \ref{cb01}]
Nous allons maintenant voir les différentes étapes pour concevoir un programme sous Code::Blocks.
\newpage \subsection{La création d'un projet}
Code::Blocks est aussi un bon gestionnaire de projets, il va pouvoir créer les bases de votre projet en quelques clics seulement et vous proposera un code initial prêt à la compilation. Vous avez la possibilité de créer votre propre modèle de projet mais si l'envie vous manque vous pourrez tout à fait choisir un modèle parmi les nombreux proposés allant de la simple application console jusqu'au projet QT, en passant par le SDL ou encore Matlab Project. Ensuite, il vous demandera de donner un nom au projet et une localisation. Après une vérification de l'emplacement des librairies, vous aurez le choix entre pas moins de 20 compilateur, GCC étant l'option par défaut. Enfin il vous sera demandé si le debugger, par défaut GDB, doit être intégré au projet mais nous y reviendront plus tard.
[Voir la Figure \ref{cb02}]
Avant de commencer à programmer (et même après) vous avez la possibilité d'activer l'autoversioning et même de commencer une liste de " TODO " afin de partager le travail avec vos éventuels collaborateurs. Voilà vous êtes maintenant prêt à saisir votre code.
[Voir la Figure \ref{cb03}]
\newpage \subsection{La programmation}
Vous entrez alors dans une phase d'écriture longue et laborieuse, heureusement Code::Blocks est là pour vous aider. Concentrons nous d'abord sur l'éditeur de texte. De prime abord on constate qu'il possède bien la " coloration syntaxique " qui permet de mettre en couleur les mots-clés de votre langage de programmation ainsi que les éléments de ponctuation, utile pour éviter les fautes de frappe et la relecture. Le second élément flagrant est la " volonté " de Code::Blocks à vous faire coder proprement : en effet il possède un système d'indentation automatique qui formatera votre code lisiblement. Ces deux premiers éléments sont tous deux paramétrables dans les menus déroulants. Ensuite l'éditeur possède un système de complètement : après la saisie des trois premières lettres d'un mot, un menu déroulant apparaîtra dans lequel se trouveront toutes les possibilités de saisies, libre à vous de choisir la bonne et de taper " Entrée ". Ceci fonctionne aussi pour la ponctuation et la création de blocs : lors de la saisie d'une parenthèse, crochet, accolade ou guillemet ouvrant son homologue fermant est aussi inséré, évitant bon nombre d'oublis. Le dernier aspect notable de cet éditeur est la possibilité de replier des blocs de code telle une arborescence de fichiers.
[Voir la Figure \ref{cb04}]
Ensuite Code::Blocks vous offre une vue globale de tous les éléments de votre projet. Il permet d'ajouter, de supprimer et de parcourir aisément tous les fichiers au travers de l'explorateur. Un simple clic droit sur un identifiant permet l'apparition d'un riche menu contextuel avec, entre autre, la possibilité de rechercher la déclaration, l'implémentation, les occurrences, les appelés ou encore les appelant d'une fonction ou d'une simple variable. Le menu déroulant " Search " contient des outils utiles de recherche mais aussi un outil " Replace in files... " très utile pour remplacer toutes les occurrences d'une chaîne de caractères par une autre. Côté programmation objet, Code::Blocks n'est pas en reste puisqu'il possède un outil de création de classe très complet (" File , New , Class... "). Enfin on peut remarquer la présence du plug-in DoxyBlocks qui permet une génération de documentation simplifiée.
[Voir la Figure \ref{cb05}]
Avec tout la programmation est simplifiée il est maintenant temps de terminer le projet en le compilant … Enfin s'il n'y a pas d'erreurs.
\newpage \subsection{La compilation}
Côté compilation, les options sont vastes que ce soit au niveau du choix du compilateur ou encore de celui des options, tout est possible. Vous aurez la possibilité d'ajouter une option manquante le cas échéant. Vous aurez aussi la possibilité de personnaliser votre propre Makefile. En tout cas la compilation de votre projet sera très instinctif, elle ce fait effectivement grâce, entre autre, aux boutons que l'on remarque dès la première ouverture de Code::Blocks. Le " rouage " permet de compiler, la " flèche verte " d'exécuter, la somme des deux de faire les deux et les flèches bleues de reconstruire tout le projet. Le résultat de la compilation apparaît alors dans la console de sortie. Si tout est correct vous obtiendrez un message du genre dans " Build log " :
\begin{center}" Process terminated with status 0 (0 minutes, 12 seconds) \newline
0 errors, 0 warnings (0 minutes, 12 seconds) "
\end{center}
[Voir la Figure \ref{cb06}]
Sinon il faudra recourir au debugger, qui ne sera autre que GDB. Pour ceci il suffit de cliquer sur la " flèche rouge " pour lancer le debuggage. À la rencontre d'une erreur, la ligne concernée vous est indiquée, vous pouvez demander la pile d'appel, l'état des variables, etc. Vous avez aussi la possibilité de placer des breakpoints par un simple clique dans la marge. Les icônes à côté de la " flèche rouge " permettent l’exécution ligne par ligne, bloc par bloc, jusqu'à la ligne courante, etc. Bref, toutes les fonctionnalités d'un debugger sont présentes.
[Voir la Figure \ref{cb07}]
\end{onehalfspacing}
\clearpage \section*{\underline{Conclusion}} \addcontentsline{toc}{section}{Conclusion}
\begin{doublespace}
Un environnement de développement intégré est donc un outil non pas essentiel, mais naturel à utiliser. Bien plus pratique qu'un simple Emacs, gedit ou Vi, il permet de gagner du temps. Cette rapidité est acquise grâce à de nombreux raccourcis, aux nombreuses erreurs et à leur résolution interminable évitées. On apprécie la qualité de confort offerte par les IDE devant la primitivité du développement universitaire sous un éditeur de texte simple. La saisie du code est beaucoup plus simple car le programmeur est foncièrement plus assisté et cela est une aide non négligeable pour un programmeur débutant. La clarté d'un code lu sous un IDE est aussi un plus pour son étude, ainsi quand sous Code::Blocks on tombe sur une fonction inconnue un simple clic droit puis l'utilisation de " Find implementation of: ... " est un luxe qui permet de comprendre plus vite un code et donc d'optimiser sa vitesse de travail.
Concernant plus précisément Code::Blocks, son utilisation nous a été très bénéfique durant ce semestre puisque centré sur le C. On peut noter toutefois que bien que la puissance de cet outil soit immense, sa spécificité limite son utilisation aux langages C/C++, D et Fortran. Nous n'avons pas pu ici détailler la foultitude de plug-in présent sur Code::Blocks mais il faut savoir qu'il en existe suffisamment pour que Code::Blocks puissent humblement concurrencer ses paires commerciaux. Il est certain que nous utiliserons tous un IDE dès lors que nous en aurons l'occasion.
\newpage \def\refname{Bibliographie} \bibliographystyle{plain} \bibliography{biblio} \addcontentsline{toc}{section}{Bibliographie}
\clearpage \listoffigures \addcontentsline{toc}{section}{Table des figures}
\clearpage
\begin{figure}
\includegraphics[scale=0.3]{./images/cb01.png}
\caption{Code::Blocks}
\label{cb01}
\end{figure}
\begin{figure}
\includegraphics[scale=0.35]{./images/cb02.png}
\caption{Configuration du nouveau projet}
\label{cb02}
\end{figure}
\begin{figure}
\includegraphics[scale=0.35]{./images/cb03.png}
\caption{Code par défaut clé en main}
\label{cb03}
\end{figure}
\begin{figure}
\includegraphics[scale=0.55]{./images/cb04.png}
\caption{Fonctionnalités intéressantes de l'éditeur de texte}
\label{cb04}
\end{figure}
\begin{figure}
\includegraphics[scale=0.45]{./images/cb05.png}
\caption{Quelques outils pratiques}
\label{cb05}
\end{figure}
\begin{figure}
\includegraphics[scale=0.6]{./images/cb06.png}
\caption{La compilation}
\label{cb06}
\end{figure}
\begin{figure}
\includegraphics[scale=0.5]{./images/cb07.png}
\caption{Le débuggage}
\label{cb07}
\end{figure}
\end{doublespace}
\end{document}