%% LyX 2.1.4 created this file.  For more info, see http://www.lyx.org/.
%% Do not edit unless you really know what you are doing.
\documentclass[french]{amsbook}
\usepackage{ae,aecompl}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\setlength{\parskip}{\smallskipamount}
\setlength{\parindent}{0pt}
\usepackage{textcomp}
\usepackage{url}
\usepackage{amsthm}
\usepackage{amssymb}

\makeatletter

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
\providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Textclass specific LaTeX commands.
\numberwithin{section}{chapter}
\numberwithin{equation}{section}
\numberwithin{figure}{section}
\newenvironment{lyxcode}
{\par\begin{list}{}{
\setlength{\rightmargin}{\leftmargin}
\setlength{\listparindent}{0pt}% needed for AMS classes
\raggedright
\setlength{\itemsep}{0pt}
\setlength{\parsep}{0pt}
\normalfont\ttfamily}%
 \item[]}
{\end{list}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
\newcommand{\N}{\mathbb{N}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\Q}{\mathbb{Q}}
\newcommand{\R}{\mathbb{R}}
\newcommand{\C}{\mathbb{C}}
\usepackage{hyperref}
%BEGIN LATEX
\makeatletter
% Yucky bugware to make hyperref and babel[francais] work together
\def\url#1{\foreignlanguage{english}{\hyper@normalise\url@{#1}}}
\def\href#1#2{\foreignlanguage{english}{\hyper@normalise\href@{#1}{#2}}}
\makeatother
\newcommand{\solution}{ \vspace{2cm}}
% Bug fix: without forcing the switch to francais after \begin{document}, chapter, table of contents and others are not translated properly.
\AtBeginDocument{
\selectlanguage{francais}
}
%END LATEX

\makeatother

\usepackage{babel}
\makeatletter
\addto\extrasfrench{%
   \providecommand{\og}{\leavevmode\flqq~}%
   \providecommand{\fg}{\ifdim\lastskip>\z@\unskip\fi~\frqq}%
}

\makeatother
\begin{document}

\title{Utilisation de l'outil informatique}

\maketitle
\tableofcontents{}


\chapter{Présentation}

\emph{Si tu donnes un poisson à un homme, ce soir il sera rassasié;}

\emph{Si tu lui apprends à pécher, toute sa vie il sera rassasié.}


\section{Objectifs}

L'objectif de ce cours est de vous amener au plus vite à l'autonomie
face à l'outil informatique, de façon à ce que vous puissiez:
\begin{enumerate}
\item Choisir en connaissance de cause les outils adaptés à vos besoins;
\item Progresser par vous-même en apprenant à utiliser de nouveaux langages,
de nouveaux outils;
\item Comprendre les enjeux du monde informatique
\end{enumerate}
Vaste programme? Pas tant que ça en fait, à partir du moment où
\begin{itemize}
\item vous connaissez les concepts essentiels;
\item vous savez chercher l'information.
\end{itemize}

\section{Organisation}

Il y aura en tout 3 ou 4 TPs qui seront à rendre à dates régulières:
je les regarderais pour voir quelles difficultés vous avez pu rencontrer
et, le cas échéant, vous donner un coup de main. Ils ne seront pas
notés. Certains de ces TPs sont longs, de façon à donner du grain
à moudre à ceux qui ont déjà une certaine expérience. Essayez d'en
faire le maximum, mais ne vous inquiétez pas outre mesure si vous
n'arrivez pas à les terminer.

Dans les dernières séances, vous travaillerez sur un questionnaire
et sur un projet de programmation que vous finirez dans les semaines
qui suivent. Votre note sera établie en fonction de la qualité du
document contenant vos réponses et sur ce projet. Comme les niveaux
de chacun sont très hétérogènes, j'essayerais de tenir compte des
progrès effectués autant que du niveau réel. 

Les premiers TP seront effectués en java, sous \texttt{GNU/Linux}.
Par la suite, vous pourrez utiliser le langage et l'environnement
de programmation de votre choix, du moment que ce choix est motivé,
et fait en connaissance de cause. Personnellement, mon environnement
de programmation préféré est actuellement:
\begin{description}
\item [{Système~d'exploitation}] \texttt{GNU/Linux}
\item [{Langages}] \texttt{C++}, \texttt{MuPAD}, \texttt{perl}
\item [{Compilateur}] gcc et consorts
\item [{Éditeur~de~texte}] Emacs
\item [{Déboguer}] gdb et consorts, sous emacs
\item [{Gestionnaire~de~version}] \texttt{CVS}
\item [{Interpréteur~de~commande}] \texttt{zsh}
\item [{Traitement~de~texte}] \texttt{\LaTeX{}}, \texttt{\LyX{}}
\item [{Navigateur}] \texttt{konqueror}
\item [{Moteur~de~recherche}] \texttt{google}
\item [{Environnement~graphique}] \texttt{KDE}
\end{description}
Vous aurez deviné qu'en dehors de ces cours je suis aussi un défenseur
des logiciels libres, mais ceci ne doit pas fausse\textquotedbl{}r
votre réflexion propre.


\chapter{Conventions pour les TPs et projets}


\section{Objectifs}

Nous allons fixer un ensemble de règles et de conventions dans la
façon d'écrire d'organiser les programmes que vous nous rendrez dans
le cadre des TP et des projets d'informatique du DESS, pour les modules
Outils Informatique, Remise à Niveau Informatique et Système et Réseaux.
Les TP et projets qui ne suivent pas ces règles seront rejetés.

Le but de ces règles est d'une part d'obtenir des programmes plus
faciles à relire, à modifier et à déboguer, et d'autre part de simplifier
les échanges de programmes, entre vous, et entre vous et nous. L'objectif
est avant tout de vous faire prendre de bonnes habitudes de programmation,
ce qui vous fera gagner beaucoup de temps à l'usage.

Attention, nous n'affirmons certainement pas que ces règles sont uniques
et les meilleures au monde; certaines de ces conventions sont en effet
purement arbitraires. Toute communauté de développeurs se créé, par
nécessité, de telles conventions pour rendre possible le travail en
équipe. Dans certain cas, ces règles sont précisément codifiées dans
un document (en anglais un \emph{Coding Standard}). Dans d'autres
cas, il s'agit plutôt d'un folklore oral informel. Dans tous les cas,
il est important au moment d'intégrer une équipe d'apprendre et de
suivre les règles qui y ont cours. Ceci n'a d'ailleurs rien de bien
spécifique à l'informatique: «à Rome, agit comme les romains». Bien
entendu, il est toujours possible de proposer des améliorations de
ces règles, une fois que l'on en a bien compris les motivations! Aussi,
n'hésitez-pas non plus à demander le pourquoi du comment de ces règles.

Certaines de ces règles nécessitent des outils que vous n'avez probablement
jamais utilisés auparavant. Pas de panique, il n'y a rien de bien
difficile, et on vous expliquera au fur et à mesure comment s'en servir.
En particulier, on vous montrera comment automatiser la plupart des
tâches.


\section{Les règles}

À part la toute première séance, vous utilisez systématiquement le
logiciel CVS pour gérer les versions de vos programmes.

Vous rendrez vos TPs et projets sous la forme d'une archive au format
\texttt{.tar.gz} de votre répertoire de travail, que vous recopierez
dans le répertoire \texttt{\textasciitilde{}nthiery/TP/nomDuTP/}.
Le répertoire de travail lui-même sera architecturé comme suit:
\begin{lyxcode}
nomDuTP-Nom.Prénom-Version/

~~~README:~~~~~Descriptif~de~l'archive

~~~Makefile:~~~Descriptif~des~règles~de~compilation

~~~rapport.html~ou~rapport.pdf:~Compte~rendu

~~~bla.java:~~~Sources~du~programme

~~~...

\end{lyxcode}
\begin{itemize}
\item \texttt{nomDuTP} est de la forme OI-TP1, RN-TP5, SR-TP3 pour respectivement
les TPs d'Outil Informatique, de Remise à Niveau et de Système et
Réseaux.
\item Le fichier README contient la date, une description courte du contenu
de l'archive, une liste des fichiers avec description courte de leur
rôle respectifs.
\item S'il y a plusieurs auteurs, le fichier \texttt{AUTHORS} contient la
liste des auteurs. Note: pas plus de trois personnes par groupes!
\item Sauf exception, le Makefile contient ce qu'il faut pour que:

\begin{itemize}
\item \texttt{make} ou \texttt{make all} lance la compilation du (des) programme(s);
\item \texttt{make demo} lance une démonstration du (des) programme(s);
\item \texttt{make check} lance la batterie de tests;
\item \texttt{make doc} fabrique la documentaion html avec javadoc;
\item \texttt{make clean} nettoie les fichiers temporaires.
\end{itemize}

Dans le cas contraire, le fichier \texttt{README} spécifie explicitement
comment faire à la main les actions correspondantes.

\item Chaque fichier source contient un entête précisant la révision, le
nom de l'auteur et une description succincte.
\item Chaque fonction et classe est accompagnée d'une documentation succincte.
Pour les fonctions java, cette documentation est au format javadoc.
Cette documentation décrit les préconditions éventuelles, le résultat,
la liste des exceptions que la fonction peut renvoyer, ainsi que quelques
exemples d'utilisation. Si l'algorithme utilisé n'est pas trivial,
la documentation inclue des explications ou des références.
\item Pour chaque fonction, il y a une série de tests dans la batterie de
tests. Ces tests doivent au moins inclure les cas extrêmes triviaux,
quelques cas simples, et quelques cas plus élaborés.
\item Le code est indenté de façon systématique et uniforme.
\item Sauf dans les cas triviaux (par exemple \texttt{i} pour un compteur
d'une boucle simple), les variables ont des noms longs et significatifs.
Si le nom n'est pas complètement explicatif, ou s'il y a des contraintes
supplémentaires sur la variable, cela est documenté à l'endroit où
la variable est définie.
\item Les invariants de boucle et les assertions non triviales seront documentées,
et testée avec assert.
\item Les constantes sont déclarées de manière groupées, par exemple en
entête de fichier.
\item La pollution de l'espace de nom principal doit être limité au maximum:
pas de variables globales, utilisation de package, \ldots{}
\item Lorsqu'une analyse des résultats obtenus est demandée, ou lorsque
vous le jugez utile, vous pouvez joindre un compte rendu succinct,
au format \texttt{HTML} ou \texttt{PDF.}
\item Pour ceux qui veulent aller plus en avant, je conseille fortement
d´écrire tous les commentaires en anglais. Je n'adore pas particulièrement
l'anglais, mais si vous étiez amenés à échanger vos programmes avec
des programmeurs étrangers, il sera probablement plus facile pour
eux de lire de l'anglais que du français. Par contre, autant que faire
ce peux, la documentation utilisateur doit être disponible en français.
\end{itemize}

\chapter{Mardi 30/09/2003, mercredi 1/10/2003: TP1, bases d'UNIX, CVS}

À rendre pour le mercredi 01/10/2003.


\section{Le shell, ou comment faire du lego sous UNIX}
\begin{itemize}
\item Tout programme a une entrée standard, une sortie standard et une sortie
d'erreur
\item Exemples: echo, cat, grep, perl, tee, locate, more / less, sort, wc\\
\texttt{perl -n -e '/bla/ and print'}~\\
\texttt{perl -n -e '/\textasciicircum{} (\textbackslash{}d+) \textbackslash{}s+
(\textbackslash{}w+) /x and print \textquotedbl{}\$2 \$1\textbackslash{}n\textquotedbl{}'}
\item On peut combiner ces briques de base en redirigeant les entrées et
sorties dans des fichiers avec \texttt{<}, \texttt{>}, \texttt{>!},
\texttt{>\textcompwordmark{}>}, \texttt{2>}, ou dans des tuyaux avec\texttt{|}.
\item Pour les détails, voir les manuels de ces commandes (man echo, man
cat), et les références!
\end{itemize}

\subsection{Références}

Il existe sur internet pleins de bons sites de référence sur l'utilisation
d'UNIX. Voir par exemple, en français, \url{http://www.eleves.ens.fr/tuteurs/},
\url{http://lea-linux.org} (et en particulier \url{http://lea-linux.org/admin/shell.php3}),
ou \url{http://www.newtolinux.org.uk/tutorials/shell_fr.shtml}.


\section{Utilisation de CVS (Concurrent Version System)}


\subsection{Introduction}

Voici un texte de «propagande» que j'avais écrit aux US pour un tutoriel
que j'y avais donné sur CVS:

Have you ever made a modification to a document, and later wondered
if it was not better before? Have you ever broken a working program,
without knowing how to undo your changes? Have you ever told your
sponsor \textquotedbl{}That's really too bad, we cannot make you a
demonstration. We are right now in an experimental phase, and our
program is not working\textquotedbl{}. Or simply, have you ever destroyed
accidentally an article just before the deadline (of course it was
Sunday, and there was no system administrator around to get a backup)
? 

If you answered yes to any of those questions, spending one hour right
now to learn how to use CVS might save you many hours and headaches
in the future. CVS means Concurrent Version System; it is a version
control system which can record the history of your files (usually,
but not always, source code). CVS only stores the differences between
versions, instead of every version of every file you've ever created.
CVS also keeps a log of who, when and why changes occurred, among
other aspects.


\subsection{Utilisation}


\subsubsection{Configuration de cvs}

On commence par définir la variable d'environnement CVSROOT qui indique
à CVS l'emplacement de son archive: ici on a choisi le sous-répertoire
CVSROOT du répertoire utilisateur. La façon de faire dépends du système:
\begin{itemize}
\item Sous windows: \texttt{set cvsroot=D:\textbackslash{}myhome\textbackslash{}CVSROOT}
(sous Windows)
\item Sous UNIX, avec sh/bash/zsh/...\texttt{: export CVSROOT=\$HOME/CVSROOT} 
\item Sous UNIX, avec csh/...\texttt{: setenv CVSROOT \$HOME/CVSROOT} 
\end{itemize}
En fait, sur les machines Linux de Gerland, \texttt{cvs} devrait déjà
être configuré convenablement! Vous pouvez faire \texttt{echo \$CVSROOT}
pour vérifier.

La toute première fois, il faut initialiser l'archive avec: \texttt{cvs
init}


\subsubsection{Gestion des modules}

Pour créer un nouveau module, le plus simple est de créer un répertoire
avec le nom du module dans l'archive avec: \texttt{mkdir \$CVSROOT/essai}.
C'est la seule fois où vous modifierez l'archive directement, le reste
du temps c'est \texttt{cvs} qui s'en chargera! En fait, même là on
serait sensé utiliser \texttt{cvs} pour créer le module avec la commande
\texttt{cvs import}, mais nous ne rentrerons pas dans ces détails.

Pour utiliser ce module, il faut en créer une copie de travail avec:
\texttt{cvs checkout essai} (en bref \texttt{cvs co essai}). Maintenant
vous pouvez travailler dans le répertoire \texttt{essai} comme dans
tout répertoire. Vous remarquerez qu'il contient un sous-répertoire
CVS qui contient des informations utiles pour \texttt{cvs}. Normalement
on a jamais besoin d'y toucher! Lorsque l'on a fini son travail, c'est
une bonne habitude de détruire la copie de travail après l'avoir archivé.
Cela se fait avec: \texttt{cvs release -d essai} depuis le répertoire
parent.


\subsubsection{Gestion des fichiers d'un module et archivage}

Allez dans la copie de travail de \texttt{essai}, et créez-y quelques
fichiers texte avec votre éditeur préféré. 

Très rapidement, la copie de travail sera encombré de fichiers temporaires
qui n'ont pas besoin d'être archivés (\texttt{machin.class},\ldots{}).
Il faut donc indiquer à \texttt{cvs} la liste des fichiers à archiver.
Cela se fait avec la commande: \texttt{cvs add fichier}; vous pouvez
donner un descriptif au fichier avec \texttt{cvs add -m'Source de
la classe Bidule' Bidule.java}. La même commande sert à ajouter des
sous-répertoires. Si, plus tard, un fichier devient inutile, vous
pouvez l'indiquer à \texttt{cvs} avec la commande \texttt{cvs remove
fichier.} Il faut avoir détruit le fichier au préalable!

Aussi souvent que vous le souhaitez, vous pouvez demander à \texttt{cvs}
d'archiver la version courante d'un fichier avec: \texttt{cvs commit
fichier} (en bref \texttt{cvs ci fichier})\texttt{.} \texttt{cvs}
vous demande alors de rentrer un descriptif des modifications. Vous
pouvez archiver tout les fichiers dans le répertoire courant d'un
seul coup avec: \texttt{cvs commit} (en bref \texttt{cvs ci}). 

Quand archiver ? Idéalement:
\begin{itemize}
\item Il n'y a dans l'archive que des versions stables (en particulier qui
passent tous les tests),
\item Entre deux versions successives, il n'y a qu'une seule modification
(cette modification peut toucher plusieurs fichiers!)
\end{itemize}
C'est pas toujours facile à faire, et il peut arriver que l'on ait
besoin de faire des compromis.


\subsubsection{Utilisation de l'archive}

C'est bien d'archiver des versions, mais encore faut-il pouvoir utiliser
cette archive! 

Vous pouvez demander les informations sur un fichier avec \texttt{cvs
log fichier}. Pour demander les différences par rapport à une ancienne
révision: \texttt{cvs diff -r1.2 fichier}. C'est une des commandes
les plus importantes de \texttt{cvs}: si vous avez fait des modifications
et vous remarquez qu'il y a un nouveau bogue, vous avez immédiatement
la liste exacte des modifications; cela permet de localiser très finement
les sources potentielles du bogue.

À tout moment, vous pouvez revenir à une ancienne révision avec: \texttt{cvs
update -r1.2 fichier}. C'est utile pour faire une démonstration lorsque
la version courante est cassée! Il est possible d'apporter des modifications
à une telle ancienne version, mais cela demande de créer une nouvelle
branche de révisions; nous ne rentrerons pas dans ces détails ici.
Pour revenir à la toute dernière version, tapez: \texttt{cvs update
-A fichier}. Si vous voulez juste consulter une ancienne révision
vous pouvez aussi faire: \texttt{cvs update -r1.2 -p fichier | less}.


\subsubsection{Tags}

Lorsqu'une version vous paraît importante, vous pouvez lui donner
un nom avec la commande \texttt{cvs tag essai-1\_0}. Vous pouvez ensuite
utiliser ce nom dans toutes les commandes au lieu du numéro de révision.
C'est d'autant plus pratique que ce numéro de révision varie d'un
fichier à l'autre. Par exemple, vous pouvez créer une copie de travail
fraîche avec la version 1.0 de votre logiciel avec: \texttt{cvs checkout
-r essai-1\_0 essai}. 


\subsubsection{Pour aller plus loin}

Ce ne sont que les commandes essentielles de \texttt{cvs}. Il y a
beaucoup d'autres commandes qui sont bien utiles. En particulier,
un des atouts de \texttt{cvs} est de faciliter le travail de plusieurs
personnes sur le même projet. Je recommande de consulter, par exemple,
les références suivantes:
\begin{description}
\item [{Documentation~en~ligne}] \texttt{info cvs}
\item [{Sites~web~de~CVS}] \url{http://www.nongnu.org/cvs/}
\item [{CVS~pour~windows}] \url{http://www.wincvs.org}
\item [{CVS~pour~windows~en~ligne~de~commande}] \url{http://www.hpcc.ecs.soton.ac.uk/hpci/tools/cvs/binaries/windows/}
\item [{Tutoriels:\url{http://www.csc.calpoly.edu/~dbutler/tutorials/winter96/cvs/}}] \url{http://www.loria.fr/~molli/cvs/cvs-tut/cvs_tutorial_toc.html}
\end{description}

\subsubsection{Comment est-ce que cela marche?}

Soyez curieux, allez voir le contenu des répertoires \texttt{CVS}
et de l'archive dans \texttt{CVSROOT}!


\section{Sujet du TP}

Créez deux fichiers \texttt{bla1} et \texttt{bla2} avec votre éditeur
favori (par exemple emacs). Utilisez la commande \texttt{cat} pour
concaténer les deux fichiers, et mettre le résultat dans \texttt{bla}.
Rajoutez une ligne contenant \texttt{coucou} à la fin fichier \texttt{bla},
(indication: utiliser \texttt{>\textcompwordmark{}>}).

%

Récupérez un gros fichier de texte (cf. par exemple sur http://www.promo.net/pg/
\url{http://www.promo.net/pg/}). Comptez le nombre de lignes et de
mots dans le texte; comptez le nombre d'occurrences d'un mot clef
de votre choix (indication: utilisez \texttt{grep} et \texttt{wc};
on pourra se contenter de compter le nombre de lignes contenant le
mot clef). Regardez le contenu du fichier avec la commande \texttt{less}
(indication: h donne accès à l'aide de \texttt{less}); à l'intérieur
de \texttt{less}, utilisez \texttt{/mot} pour recherchez les mots
clefs.

%

Explorez le système de fichier. Par exemple, visualisez le contenu
du fichier \texttt{/etc/passwd}, listez tous les programmes dans \texttt{/usr/local/bin},
ou recherchez toutes les images au format gif du système (indication:
utilisez \texttt{locate}).

%

Suivez le tutoriel \url{http://lea-linux.org/dev/shell_script.php3}
pour écrire de petits scripts.

%

Récupérez l'archive suivante, et décompressez-la (indication: utilisez
les commandes \texttt{gunzip} et \texttt{tar}). 

\url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/OI-TP1-Nicolas.Thiery-1.0.tar.gz}

Vous obtenez un répertoire de la forme \texttt{OI-TP1-Nicolas.Thiery}.
Entrez dedans, et essayez les différentes commandes \texttt{make},
\texttt{make demo}, \texttt{make check}, \texttt{make doc}. Utilisez
votre navigateur préféré pour visualiser les fichiers \texttt{.html}
créés. De même, utilisez \texttt{kdvi} (par exemple) pour visualiser
les fichiers \texttt{.dvi}, et \texttt{gv} pour les fichier \texttt{.ps},
et \texttt{.pdf}. Enfin, utilisez \texttt{make clean}, pour faire
le nettoyage.

Toutes ces commandes utilisent le fichier \texttt{Makefile}. Regardez
son contenu, et essayez de reproduire les commandes qu'il contient
à la main. 

%

Maintenant, vous allez personnaliser ce répertoire. Faites en une
copie sous le nom \texttt{OI-TP1-Prenom.Nom-1.0} (OI pour Outil Informatique)
dans votre répertoire principal (Indication: utiliser \texttt{cp -p}).
Utiliser votre éditeur préféré pour modifier le contenu des fichiers
\texttt{Makefile} et \texttt{README} de façon conforme au cahier des
charges. Faites aussi quelques modifications aux fichiers \texttt{\LaTeX{}}
(avec votre éditeur), et \texttt{\LyX{}} (avec \texttt{lyx}).

%

Vous allez passer ce répertoire sous \texttt{CVS}, afin de pouvoir
archiver les différentes versions au fur et à mesure. Créez un module
\texttt{DESS}, et demandez en à \texttt{CVS} une copie de travail
dans \texttt{\textasciitilde{}/DESS}. Déplacez le répertoire dans
cette copie de travail sous le nom \texttt{OI-TP1}. Enregistrez le
avec \texttt{cvs add}, ainsi que tous les fichiers importants dedans.
Enfin utilisez \texttt{cvs commit}, pour tout archiver. Travaillez
encore un peu dessus, archivez la nouvelle version, utilisez \texttt{cvs
diff} pour voir les différences, etc.

Quand tout est fini, utilisez tar et gzip pour fabriquer une archive
\texttt{OI-TP1-<Prenom>.<Nom>-<Version>.tar.gz} de votre répertoire
de travail.

Enfin copiez cette archive dans le répertoire \texttt{\textasciitilde{}nthiery/TP/OI-TP1/.} 

Deux petites notes: 
\begin{enumerate}
\item Comme indiqué dans les conventions, le répertoire contenu dans l'archive
doit aussi s'appeler \texttt{OI-TP1-<Prenom>.<Nom>-<Version>}; 

\begin{enumerate}
\item Pour les prochains TP, vous pourrez simplement utiliser \texttt{make
dist} pour créer cette archive \texttt{.tar.gz.}
\end{enumerate}
\end{enumerate}

\chapter{Mercredi 01/10/2003: TP2, java et outils de programmation}

À rendre pour le 06/10/2003.

Récupérez l'archive suivante, et décompressez-la avec les commandes
\texttt{gunzip} et \texttt{tar:}\url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/OI-TP2-Daniel.Tounissoux-Nicolas.Thiery-1.0.tar.gz}.
Entrez dans le répertoire créé, et essayez les différentes commandes
\texttt{make}, \texttt{make demo}, \texttt{make check}, \texttt{make
doc}. Le sujet du TP est dans le fichier \texttt{sujet.pdf}.

Correction:

\url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/OI-TP2-Daniel.Tounissoux-Nicolas.Thiery-1.0-Correction.tar.gz}

Références:
\begin{itemize}
\item Cours Java de Daniel Tounissoux \url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/Cours-Java-Tounissoux.pdf.gz}
\item Site de SUN sur Java, avec des tutoriaux, ... \url{http://java.sun.com/}
\item Documentation java, en local \url{file:/usr/java/docs/api/index.html}
\item Documentation de la bibliothèque java, en local \url{file:/usr/java/docs/api/index.html}
\end{itemize}

\chapter{Mardi 07/10/2003: TP3, java et objets}

À rendre pour le 14/10/2003.

\url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/OI-TP3-Daniel.Tounissoux-Nicolas.Thiery-1.0.tar.gz}

Ce TP classe s'appuie sur les utilitaires standard de java, et en
particulier java.util.ArrayList. Voir la documentation de référence.
Voilà un micro résumé des commandes java qui vous seront utiles:
\begin{lyxcode}
import~java.util.ArrayList;

l=new~ArrayList()~//~crée~un~nouveau~tableau

l.add(1);~//~rajoute~un~élément~à~la~fin

l.size();~//~la~taille~du~tableau

l.get(0);~//~le~premier~élément~du~tableau

l.set(0,new~Integer(3));~//~rentre~la~valeur~3~dans~le~premier~élément~du~tableau



i=new~Integer(3);

j=new~Integer(4);

i.compareTo(j);~//~renvoie~un~nombre~négatif

j.compareTo(i);~//~renvoie~un~nombre~positif

i.compareTo(i);~//~renvoie~0
\end{lyxcode}

\chapter{Semaine du 28 octobre au 1 novembre: TP4: tutoriel }

Dans la vraie vie, vous aurez régulièrement besoin d'apprendre par
vous-même de nouveaux langages de programmation, de nouveaux logiciels.
L'objectif de ce TP est de vous entraîner à cela. Vous allez choisir
un langage de programmation que vous ne connaissez pas (\texttt{perl},
par exemple), chercher un tutoriel sur le web, et le suivre. Pour
le 6 novembre, vous rendrez comme d'habitude une archive .tar.gz contenant
les programmes que vous aurez écrit.

Pour la semaine prochaine, répondez aux questions marquées d'une étoile
({*}) dans le questionnaire.


\chapter{Projet: Implantation d'un joueur automatique de Hex}

Première version à rendre pour le mercredi 26 novembre. Version définitive
pour le 10 décembre.

L'objectif de ce projet est d'implanter des joueurs automatiques pour
le jeu de Hex.

On demande au minimum d'implanter les joueurs suivants:
\begin{itemize}
\item Méthode gloutone avec plusieurs fonctions d'évaluations (distance
ou autre);
\item Méthode min/max (recherche exhaustive) pour trouver une stratégie
gagnante;
\item Méthode alpha/beta pour trouver un coup raisonnable
\end{itemize}
Pour aller plus loin:
\begin{itemize}
\item Implantation d'autres fonctions d'évaluation pour alpha/beta, en particulier
par \og mesure de résistance \fg{}.
\item Implantation d'autres méthodes.
\end{itemize}
Le squelette du projet, contenant entre autres une interface graphique,
est fourni: \url{http://lapcs.univ-lyon1.fr/~nthiery/DESS/Notes/Exemples/OI-Projet-Nicolas.Thiery-1.0.tar.gz}


\chapter{Questionnaire}

Première version à rendre pour le mercredi 26 novembre, version définitive
pour le 10 décembre.

La suite de ce document est composé de questions, groupées par thèmes.
Cette liste est susceptible d'évoluer. Beaucoup vous paraîtront au
premier abord difficile, voire absconses. Ne vous fiez pas à votre
première réaction; en vous documentant, et avec un petit coup de main
de temps en temps, vous devriez être capable d'y apporter une réponse
\emph{personnelle}. J'insiste sur \emph{personnelle}. Selon vos goûts,
vos sensibilités, certaines des questions peuvent avoir des réponses
différentes, l'important étant que vos réponses soient \emph{étayées}.
Typiquement, chaque réponse devrait prendre quelques lignes et comporter
un exemple simple et une ou plusieurs références.

J'encourage très fortement le travail en grand groupe, afin de partager
le travail de recherche, de vous entraider, et de débattre les questions.
Mais une fois ce travail de fond en commun effectué, l'objectif est
que vous apportiez vous-même une réponse personnelle et détaillée
à chacune des questions. Vous me rendrez donc un document pour au
maximum deux personnes. Techniquement, ce document sera composé d'une
archive \texttt{.tar.gz} contenant un (ou plusieurs) fichier(s) \texttt{HTML}.
Ne lésinez pas sur les références et les exemples dans vos réponses:
ce document est avant tout pour vous; j'espère bien qu'il vous resservira!

Certains concepts ne sont pas évidents! Si vous avez épuisé vos ressources
sans trouver suffisamment d'éléments pour étayer votre propre réflexion,
je me ferais un plaisir de vous guider. Alors, profitez de ma présence!


\section{Langages de programmation}
\begin{enumerate}
\item Listez dix langages de programmations que vous jugez intéressants.
Pour chacun d'entre eux, préciser de manière brève le domaine d'application,
le type de langage, les caractéristiques principales, les points forts
et faibles, et toute autre information que vous jugerez utile (bonnes
références, tutoriels, mini-historique, \ldots{}).
\item Sélectionnez cinq de ces langages, et faites un tableau récapitulatif
indiquant leurs fonctionnalités. On pourra par exemple convenir d'un
système de notation: 0: fonctionalité absente, $1$: fonctionnalité
possible mais au prix de contorsions, \ldots{} $5$: fonctionnalité
parfaitement supportée. Pour chaque fonctionnalité non triviale, écrivez
un petit programme qui l'illustre.

\begin{enumerate}
\item Interpréteur et/ou compilateur
\item Portabilité
\item Programmation impérative
\item Fonctions, procédures et programmation fonctionnelle:

\begin{enumerate}
\item Récursivité
\item Les fonctions sont-elles des objets de premier niveau?
\item Fonctions anonymes
\item Fermetures, générateurs
\item Passage de paramètre par valeur et/ou par référence
\item Variables locales à portée lexicale ou dynamique
\item Macros, fonctions \emph{inline}
\item Optimisation partielle
\end{enumerate}
\item Typage, polymorphisme et programmation orientée objet:

\begin{enumerate}
\item Surcharge d'opérateurs, de fonctions
\item Typage statique et/ou dynamique
\item Programmation orientée objet
\item Classes abstraites; méthodes virtuelles
\item Classes paramétrées
\item Création au vol de nouvelles classes
\item Les classes sont-elles des objets de premier niveau?
\item Possibilité d'implanter de nouvelles structures de données aussi efficaces
que celles fournies par le système
\end{enumerate}
\item Programmation logique
\item Programmation littéraire
\item Assertions, préconditions et postconditions
\item Sémantique de copie et/ou de référence
\item Glaneur de cellules (\emph{garbage collector})
\item Librairie standard:

\begin{enumerate}
\item Structures de données classiques (listes chaînées, piles, files, vecteurs
dynamiques, tables d'associations, ensembles).
\item Calcul numérique
\item Calcul symbolique
\item Statistiques
\item Graphiques
\item Expressions régulières
\item Système et réseau
\end{enumerate}
\item Communauté:

\begin{enumerate}
\item Tutoriaux, sites d'introduction, listes de diffusions
\item Sites pour échanger du code
\item Licence d'utilisation
\end{enumerate}
\end{enumerate}
\item Quelles sont les améliorations les plus importantes, de votre point
de vue, dans Fortran 90 vis-à-vis des anciennes versions ? 
\end{enumerate}

\section{Concepts et paradigmes de programmation}
\begin{enumerate}
\item Citez dix algorithmes classiques. Classez, selon vos goûts, les cinq
plus importants.
\item Que dit, en gros, la thèse de Curry-Howard ?
\item De qui est la citation «Beware of bugs in the above code; I have only
proved it correct, not tried it» ?
\end{enumerate}

\section{Outils et méthodes de développement}
\begin{enumerate}
\item Quelles sont, selon Larry Wall, les 3 plus importantes qualités d'un
programmeur ? Pourquoi ?
\item Quels sont les avantages et inconvénients d'un environnement de programmation
intégré?
\item Quels sont les avantages et inconvénients des composants visuels et
non-visuels (cf. par exemple Borland Delphi, C++ builder, ou bien
les javabeans). Pour certaines situations (ex. créer une unité qui
effectue une régression multiple générique), est il plus intéressant
ou plus restrictif de créer un composant visuel/non-visuel? 
\end{enumerate}

\section{écriture de documents}
\begin{enumerate}
\item Faut-il mettre les accents aux majuscules dans un texte tapé en français
? Où trouver ce genre d'information ?
\item Pourquoi séparer la forme et le fond d'un document ? 
\end{enumerate}

\section{Société}
\begin{enumerate}
\item Quel critères utiliser pour dire qu'un langage de programmation, ou
un format de fichier (par ex. word, pdf, mp3) est un \emph{standard}
? Est-ce que cela a une importance ?
\item Quels sont les principes essentiels de la nétiquette ?
\item Qui a cassé l'énigme \emph{Enigma} ?
\item Qu'est-ce qu'une FAQ, une RFC ?
\item Quels sont les grands précurseurs de l'informatique avant 1940 ?
\item Quel est le point commun entre Gödel, Escher et Bach ?
\end{enumerate}

\subsection{Droit du logiciel}
\begin{enumerate}
\item Qu'est-ce qu'un logiciel libre ? (\emph{free software}, \emph{open
source software)}
\item Lorsque vous développez un logiciel, est-ce que le choix d'une licence
est important ?
\item Ai-je le droit de vendre un logiciel sous GPL; peut-on utiliser des
applications commerciales sous GNU/Linux ?
\item Y-a-t'il une différence entre un programme du domaine public, et un
programme sous licence libre ?
\item Quel peut bien être l'intérêt pour une entreprise privée de développer
un logiciel sous licence libre ?
\item Pour ou contre les brevets sur les logiciels ?
\item Pour ou contre l'usage de la cryptographie ?
\end{enumerate}

\subsection{Modèles de développement}
\begin{enumerate}
\item Indiquez, parmi les logiciels suivants, ceux qui ont un modèle de
développement de type \emph{«Cathédrale»} ou de type \emph{«Bazar»}:

\begin{enumerate}
\item Emacs
\item Linux
\item Word
\item Scilab
\end{enumerate}
\item L'homme-an est-il un mythe ?
\item Que signifie «Given enough eyeballs, every bug is shallow» ?\end{enumerate}

\end{document}
