source: trunk/doc/extreme_version_control.txt @ 2

Je ne sais pas si nous utiliserons Darcs, mais si j'avais retenu cet
outil lorsque je l'avais découvert il y a quelques temps, c'est que
ses concepts m'ont beaucoup intéressés et m'ont inspiré dans ma
réflexion sur E3 et la gestion de configuration extrême.

Une autre réflexion que je menais concernait comment fournir une
interface textuelle. Fabrice nous en a récemment rappelé
l'importance. L'autre jour, dans un éclair de lucidité, ces deux
sujets en apparence distincts se sont rejoints. Je vais essayer de
décrire cette vision.

Il faut commencer par ne plus penser au code comme un ensemble de
fichiers source, et ne plus penser au développement et à la gestion de
configuration comme une manipulation de fichiers contenant du
texte. Visualisons le code comme quelque chose de concret, qui possÚde
une structure, des formes, des relations. Par analogie, au lieu de se
mettre au niveau du code génétique (séquence d'ADN), on regarde
l'organisme vivant, sa structure cellulaire voire physiologique.

Alors, chaque intervention sur le code devient une intervention
logique, ayant un sens concret. On ne modifie pas les caractÚres 30 à 
35 de la 56Úme ligne d'un fichier, on change le nom d'une variable
locale utilisée dans une fonction donnée.

Imaginons un outil qui comprendrait cette structure du code. Pour
manipuler le code, il faut lui demander une intervention logique, pas
une édition d'un fichier source. Il offrirait tout un éventail de
commandes élémentaires (ajout d'une instruction, ajout d'un argument,
modification d'un nom de méthode...), des commandes plus complexes
composées de plusieurs commandes élémentaires (ajout d'une classe), et
des opérations intelligentes (refactoring).

Ces commandes "logiques" sont un candidat parfait pour une interface
textuelle avec l'outil. Autant ce serait débile d'imaginer une
interface en ligne de commande pour faire de l'édition de fichiers
sources (on reviendrait à l'éditeur "ed" d'Unix, c'est vraiment un
retour en arriÚre par rapport à Emacs ou d'autres IDE modernes),
autant je trouve cela intéressant, au lieu d'aller trouver un fichier
source dans une arbo, de l'ouvrir, de descendre à la 56Úme ligne, de
sélectionner un mot à la souris et de saisir "newName", de simplement
saisir :

e3 rename local variable MyModule:MyFunc:toto titi.

Surtout si l'outil est assez intelligent pour modifier toutes les
occurrences de la variable dans la fonction !

Outre l'intérêt d'offrir un langage de commande (testabilité,
intégration avec des outils externes et tout simplement ergonomie pour
une utilisation avancée), cette approche à base de "commandes
logiques" offre une vision puissante et innovante de la gestion de
configuration.

La gestion de configuration consiste à gérer les versions successives
du code, et à gérer le développement par équipes. Avec des commandes
logiques, la gestion de versions successives devient un jeu d'enfant
dÚs lors qu'on constate l'évidence que toute commande logique à une
commande inverse. Il suffit donc de conserver une trace de toutes les
commandes effectuées, et on peut à tout moment revenir en arriÚre en
appliquant une ou plusieurs commandes inverses. Notons au passage que
nous disposons par la même occasion d'une trace permettant de faire du
rejeu (Ã  des fins d'analyse d'anomalies) et offrant un enregistrement
à des fins ISO9000/CMM bien plus utile (car intelligible
sémantiquement) que des diffs et bien plus objectif et fiable que des
commentaires mis dans CVS.

Quant à la question du développement par équipe, nous avons à la fois
une façon d'égaler les fonctionnalités existantes (update, commit,
fusion...), et le moyen d'aller beaucoup plus loin.

C'est là que cela ressemble un peu à la philosophie de Darcs. Chacun
travaille de son cÎté, puis soumet au référentiel ses
modifications. Les modifications sont soumises sous la forme d'une
séquence de commandes logiques. Là où cela devient intéressant, c'est
que si les autres binÎmes décident de faire un update (de récupérer
chez eux les modifs de quelqu'un d'autre), ils le font aussi sous
forme de commandes logiques... Or une commande logique, appliquée sur
du code qui n'est pas le même que celui sur lequelle elle a été
appliquée à l'origine, ne fera pas forcément la même chose
physiquement, mais devrait en fait faire ce qu'un développeur aurait
voulu. Il ne devrait même plus y avoir de "conflits" au sens CVS. On
peut même appliquer deux "patchs" dans un ordre différent, et toujours
tomber sur un résultat correct! Par contre, on peut déceler de
véritables conflits, par exemple lorsque deux commandes logiques ont
toutes les deux cherché à renommer une fonction.

Prenons l'exemple de deux tâches menées en parallÚle qui ont modifié
la même ligne de code. Une tâche a renommé une fonction partout dans
le code, l'autre a éliminé du code dupliqué en extractant deux zones
de code semblables dans une nouvelle fonction. Or, cette zone de code
contenait un appel à la fonction dont le nom a été modifié par l'autre
tâche. CVS serait incapable de gérer cette situation. Avec l'approche
en question, c'est possible. Lorsqu'on applique la commande logique
"rename function" sur le code d'un binÎme, elle renomme la définition
et tous les appels, y compris dans les /deux/ zones de code
dupliqué. Sur le code du binÎme qui a lui supprimé cette duplication,
elle renomme la définition et tous les appels, y compris celui qui se
trouve maintenant dans la nouvelle fonction! Mais le plus fort est que
l'inverse est vrai aussi. Le binÎme ayant supprimé la duplication a
lui-même fait une séquence de commandes logiques qu'on peut appliquer
aussi au code du binÎme qui a renommé la fonction, et ce dans
n'importe quel ordre...

Du coup, c'est là qu'on peut envisager (mais il faudra expérimenter à 
l'usage) une approche consistant à "broadcaster" en temps réel toutes
les commandes logiques faites par les uns et les autres, et tout le
monde update continuellement (en fait quasiment sans s'en rendre
compte...) Et tout cela avec toujours la possibilité de faire "undo",
à la fois individuellement dans son propre espace, ou dans le
référentiel, ou globalement chez tout le monde!