:: wikimiki.org ::

Refactoring

Refactoring

Catégorie:Programmation informatique Catégorie:Génie logiciel La refactorisation (anglicisme venant de refactoring) est une opération de maintenance du code informatique. Elle consiste à retravailler le code source non pas pour ajouter une fonctionnalité supplémentaire au logiciel mais pour améliorer sa lisibilité et simplifier sa maintenance (on parle aussi de remaniement). C'est donc une technique qui s'approche de l'optimisation du code, même si les objectifs sont radicalement différents.

Pourquoi refactoriser ?

Au fur et à mesure de la vie d'un logiciel on est amené à implémenter de nouvelles fonctions ou à corriger des bugs. Or ces modifications ne se plient pas toujours avec élégance dans l'architecture du logiciel. Le code source d'un programme tend donc à devenir de plus en plus complexe au fur et à mesure de son existence. Cela est notamment vrai avec les techniques modernes de développement itératif incrémental où le logiciel entre en phase de modification pratiquement dès le début de son existence. Il est donc important de mettre en œuvre des techniques qui permettront de toujours conserver un code aussi simple que possible. Cela consiste à :
- S'assurer que toute l'information nécessaire est disponible
- Supprimer toute information redondante ou duplication de code
- Simplifier l'algorithmique des méthodes
- Limiter la complexité des classes
- Limiter le nombre de classes

Les niveaux de refactorisation

On peut distinguer plusieurs niveaux de refactorisation, selon l'impact des modification sur le déroulement du programme et les risques rencontrés. En pratique, durant une même session de refactorisation on jonglera souvent entre ces divers niveaux.

Modification de la présentation

A ce niveau on cherche à simplement améliorer la présentation du code source sans modifier le code exécuté. Ce type d'amélioration concerne donc essentiellement les commentaires (suppression des commentaires superflus, ou ajout de commentaires sur des sections complexes) et la mise en page (indentation du code, passages à la ligne).

Modification de l'algorithmique

Ce type de modification est destiné à conserver des méthodes aussi simples que possible. Cela est le plus souvent réalisé en scindant une méthode ou un algorithme en plusieurs parties ou en confiant à un objet annexe une partie du traitement. Dans ce type de modification, il est tout à fait possible (et fréquent) d'introduire des bugs, il est donc fortement conseillé de construire une batterie de tests unitaires et de l'exécuter après chaque modification.

Refonte du design

C'est le type de modification le plus radical puisqu'il consiste à modifier la hiérarchie de classes composant l'application. Il est là aussi préférable de procéder par petites modifications et d'exécuter une suite de tests à chaque fois. Il est par ailleurs très difficile de réaliser une refonte en profondeur sans outil spécialisé comme un butineur de classes.

Des activités de refactorisation

Suppression du code mort

Le code mort est du code qui ne sert à rien car il n'est jamais appelé par une autre partie du programme. Il ne sert donc qu'à rendre le source plus complexe et à provoquer des risques de confusion. Le plus difficile est bien entendu de détecter le code mort, on peut pour cela utiliser plusieurs techniques:
- recherche statique par l'outil grep sur le code source pour vérifier qu'une méthode est bien appelée quelque part
- analyseur de références croisées (par exemple l'outil objxref livré avec le compilateur turbo C de Borland)
- outil de mesure de couverture de code. C'est sans doute la méthode la plus pratique puisqu'elle permet également de vérifier des portions de méthodes. Elle est également la plus risquée puisque du code peut être marqué comme non couvert simplement parce que votre suite de test n'est pas complète (ce qui est en pratique toujours le cas). Il existe une autre forme de code mort: le code commenté. Il arrive souvent que suite à des modifications, on laisse des pans entiers de l'ancien code pour pouvoir éventuellement revenir à la version antérieure facilement. Ce type de code devrait également être supprimé à la fin de la session de développement. Dans tous les cas, il n'est jamais recommandé de conserver du code qui pourrait servir un jour. Il est toujours préférable de le supprimer de la version de travail et d'utiliser un outil de contrôle de version pour archiver ce type de code.

Ajout d'assertions

Les assertions sont une technique de programmation qui consiste à vérifier qu'un certain nombre de conditions sont vérifiées. Elles sont très intéressantes d'une part car elles permettent de simplifier le déboggage en détectant les erreurs au plus tôt, mais également parce qu'elle sont placées à l'intérieur du code qu'elles contrôlent et peuvent donc aider à la compréhension de l'état du système.

Renommage

Au fur et à mesure du développement d'un logiciel, le rôle des classes et des méthodes devient plus clair. Il est donc souvent utile de modifier les noms de classes ou de méthodes pour bien indiquer ce rôle.

Commentaires

Les commentaires sont un sujet assez controversé de documentation du logiciel. Il est de toute façon important de toujours garder les commentaires synchronisés avec le code.

Références

- Jean-Philippe Retaillé, Refactoring des applications Java/J2EE, Eyrolles, 2005, 390 p., ISBN 2212115776
- Martin Fowler, Kent Beck, Refactoring: Improving the Design of Existing Code, Addison-Wesley Professional, 1999, 464 p., ISBN 0201485672
- Joshua Kerievsky, Refactoring to Patterns, Addison-Wesley Professional, 2004, 400 p., ISBN 0321213351 ja:リファクタリング (プログラミング)

Catégorie:Programmation informatique

Cette catégorie recence les techniques de programmation en informatique. Elle n'est pas normalement utilisée pour :
- les langages de programmation
- les compilateurs, les débogueurs, et tous les outils utilisé en programmation
- les architectures
- les algorithmes qui pourront être rangé dans les sous catégories de :catégorie:développement logiciel. Catégorie:Développement logiciel ja:Category:プログラミング

Anglicisme

Catégorie:Lexicologie Catégorie:Anglais Catégorie:Expression anglophone Catégorie:Langue française On appelle anglicisme un mot ou une locution emprunté à la langue anglaise et utilisé dans une autre langue, sans être encore bien intégré(e) dans le vocabulaire de celle-ci. C'est donc un idiotisme. Un anglicisme bien intégré sera plutôt qualifié d'emprunt. Il faut noter qu'un anglicisme pour un locuteur ne le sera sans doute pas pour un autre : tout dépend de l'intérêt que porte chacun à sa langue (pour comprendre qu'un terme est un anglicisme, encore faut-il avoir quelques notions de l'histoire du lexique français et être capable de sentir fluctuations et évolutions de dernier). Nombreux sont les francophones qui ignorent, par exemple, que l'utilisation de réaliser au sens de « prendre conscience » ou encore celle dinitier pour « entreprendre, débuter » sont senties comme des anglicismes de mauvais aloi par une plus petite partie de la population qui sera, en retour, considérée comme « puriste ». Il existera même une part encore moins importante de locuteurs défendant tel ou tel anglicisme en expliquant que l'emprunt est utile. On parle aussi dans certains cas de calques, c'est-à-dire d'une traduction terme à terme d'expressions anglaises : gratte-ciel pour skyscraper (sky veut dire « ciel » et scrape « gratter »). Initier et réaliser seront quant à eux des faux-amis.
Les catégories d'anglicismes
Selon le Colpron, dictionnaire des anglicismes publié au Québec, on peut classer les anglicismes en six catégories :
- l'anglicisme sémantique : c'est l'attribution à un mot français d'une acception qu'il n'a qu'en anglais ; vol domestique pour vol intérieur ;
- l'anglicisme lexical : c'est l'emprunt de mots ou d'expressions anglais employés tels quels ; feedback (rétroaction)
- l'anglicisme syntaxique : c'est le calque de constructions syntaxiques propres à la langue anglaise ; être en charge de (< in charge of) : être chargé de
- l'anglicisme morphologique : ce sont des erreurs dans la formation des mots (genre, suffixations, etc.) ; les actifs d'une société (< the assets) : l'actif
- l'anglicisme phonétique : c'est une faute de prononciation ; cent (dollar canadien ou euro) prononcé [sɛnt]
- l'anglicisme graphique : c'est l'emploi d'une orthographe ou d'une typographie qui suit l'usage anglo-saxon ; emploi du point décimal au lieu de la virgule. L'usage du français contemporain est marqué par de nombreux anglicismes. Il ne faut pas oublier que si la tendance s'est inversée ces dernières décennies, pendant longtemps la langue anglaise a plus emprunté à la langue française que le contraire, ce qui fait que certains de ces anglicismes dans le français actuel ont été des gallicismes en anglais à une certaine époque (ex.: obsolète). Le nombre et la fréquence des anglicismes varient selon les locuteurs et selon les domaines de spécialité. Certains domaines en regorgent, comme l'économie, mais surtout l'informatique. Celle-ci, du fait de l'hégémonie économique des États-Unis d'Amérique dans ce domaine, est en effet sujette à de nombreux emprunts à l'anglais (au jargon informatique anglo-américain), la lingua franca de fait entre les informaticiens du monde entier étant l'anglais. De plus, la plupart des langages de programmation ont un vocabulaire inspiré de l'anglais ce qui fait que les programmeurs ont une tendance naturelle à penser en anglais. De nombreux anglicismes possèdent des équivalents français. Leur emploi n'est donc pas motivé par une lacune du lexique français et un réel « besoin de désignation », mais procède plutôt d'un effet de mode ou d'imitation (moteur essentiel du changement linguistique en général). Les anglicismes sont nombreux dans les pays où le français est en contact quotidien avec l'anglais (pays bilingues comme le Canada) ou qui ont été occupés par un pays anglophone (comme le Japon). La Belgique étant un pays essentiellement bilingue, le gouvernement utilise parfois des anglicismes : d'une part, cela évite d'utiliser des termes néerlandais ou français qui pourraient favoriser l'une ou l'autre communauté, d'autre part certains ministres ne maîtrisant pas bien l'autre langue, l'anglais permet alors de s'exprimer plus facilement. Une bonne part des anglicismes «récents» sont cependant apparus autour de Paris : mailing, customiser, news, chewing-gum, green. Certains anglicismes sont utilisés comme racourcis linguitique pour la jeunesse ex: Web (World-wide-web) au lieu de la Toile (anglicisme lexical)
Liste des anglicismes courants

- lexicaux
- hoax : canular (utilisé dans le contexte d'internet)
- hype : branché
- matcher : correspondre (utilisé en informatique)
- toaster : grille-pain
- walkman : baladeur
- pipeline : oléoduc
- news : nouvelles
- prime time : heure de grande écoute
- happy hours : 5 à 7
- syntaxiques
- en charge de (< in charge of) : chargé de
- est sous contrôle (< under control) : est maîtrisé
- sémantiques
- réaliser (< realize) : se rendre compte de
- initier (< initiate) : débuter, entamer
- avoir l'impression de : avoir le sentiment de
- opportunité (< opportunity) : occasion
- graphiques
- license : licence
- Redoublement de la première consonne (français : « agression », « abréviation », « adresse » ; anglais : « aggression », « abbreviation », « address »)
- connection : connexion
- a, b, et c : a, b et c
- le fait de coller certains signes de ponctuation doubles au mot qui les précède (voir en anglais les recommandations du [http://stipo.larc.nasa.gov/sp7084/sp7084ch3.html NASA's Handbook for Technical Writers and Editors]) alors qu'en français ils sont normalement précédés d'une espace. Cela concerne le point-virgule ( ; ), le deux-points ( : ), le point d'exclamation ( ! ) et le point d'interrogation ( ? ). De même pour les guillemets, qu'on tracera (« ») et non ("") :
- Il dit: "cette phrase est mal typographiée! Est-ce normal?"
- Elle répondit : « mais ceci est correct ; qu'en pensez-vous ? »
Articles connexes

- franglais
- calque
- idiotisme
Lien externe

- [http://www.cce.umontreal.ca/278.htm L'anglicisme au Québec]
- L'Office québécois de la langue française recense plus de 150 anglicismes assortis de conseils sur la façon de les éviter [http://w3.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?Th=1&Th_id=129&niveau=]

Optimisation du code

En programmation informatique, l'optimisation est la pratique qui consiste généralement à réduire le temps d'exécution d'une fonction, l'espace occupé par les données et le programme, ou la consommation d'énergie. La règle numéro un de l'optimisation est quelle ne doit intervenir qu'une fois que le programme fonctionne et répond aux spécifications fonctionnelles. L'expérience montre qu'optimiser du code avant que ces deux conditions ne soient réalisées revient le plus souvent à une perte de temps et s'avère néfaste à la clarté du code et au bon fonctionnement du programme : :« L'optimisation prématurée est la source de tous les maux. », Donald Knuth citant Dijkstra La plupart des compilateurs récents pratiquent de façon automatique un certain nombre d'optimisations qu'il serait fastidieux d'effectuer manuellement et qui rendraient le code source moins lisible. L'optimisation manuelle peut s'avérer nécessaire dans des cas très spécifiques, mais les mesures montrent que sur des machines RISC qui possèdent un nombre élevé de registres et où l'efficacité demande le regroupement des instructions identiques pour bénéficier de l'effet pipeline, l'optimiseur d'un compilateur C fournit souvent un code plus efficace que celui qui serait écrit en assembleur par un programmeur expérimenté (ce qui n'était jamais le cas sur les machines CISC). Et de surcroit ce code est bien plus facile à maintenir, car les instructions en C restent dans un ordre lié à la seule intelligibilité du code et non aux spécificités de la machine : dans les optimiseurs actuels, en effet, les ordres machines associés à une instruction ne se trouvent plus nécessairement en position contiguë, pour des raisons d'efficacité d'exécution. Cela rend le code assembleur généré particulièrement indéchiffrable.
Pratique de l'optimisation

Première approche
Avant de commencer l'optimisation, il faut savoir mesurer la vitesse du code. Pour cela il faut choisir un paramètre, de préférence simple, mesurable. Ceci peut-être par exemple le temps de traitement sur un jeu de donnée précis, ou le nombre d'images affichées par seconde, ou encore le nombre de requêtes traitées par minute. Une fois le paramètre de mesure déterminé, il faut mesurer le temps passé dans chacune des parties du programme. Il n'est pas rare que 80% à 90% du temps soit consacré à l'exécution de 10% du code (les boucles critiques). Les chiffres varient en fonction de la taille et de la complexité des projets. Il faut localiser ces 10% de code pour être le plus rentable dans ses optimisations. Cette étape de localisation peut être réalisée à l'aide d'outils spécialisés d'instrumentation du code nommés profilers. Ils sont chargés de compter le nombre d'exécutions de chaque fonction et de cycles du microprocesseur correspondants au cours de l'exécution. Ensuite on itère sur la section la plus consommatrice de ressource autant de fois que nécessaire cette boucle :
- optimisation d'une partie du code
- mesure du gain de performances
Seconde approche
On peut optimiser à plusieurs niveaux un programme:
- au niveau algorithmique, en choisissant un algorithme de complexité inférieure (au sens mathématique) et des structures de données adaptées,
- au niveau du langage de développement, en ordonnant au mieux les instructions et en utilisant les bibliothèques disponibles,
- en utilisant localement un langage de bas niveau, qui peut être le langage C ou, pour les besoins les plus critiques, le langage assembleur. On ne passe au niveau supérieur d'optimisation qu'une fois qu'on a épuisé les possibilités d'un niveau. L'utilisation d'un langage de bas niveau sur l'ensemble d'un projet pour des raisons de rapidité est l'une des erreurs les plus communes et les plus coûteuses que puisse faire un projet industriel. L'optimisation de code est considéré par beaucoup de développeurs amateurs comme un art un peu magique et, pour cette raison, comme l'une des parties les plus excitantes de la programmation. Ceci les conduit à croire qu'un bon programmeur est une personne qui optimise d'emblée le programme. Cependant l'expérience montre qu'elle ne peut pallier une mauvaise conception initiale. C'est dans la conception que l'expérience du développeur joue le plus. Par ailleurs, dans un nombre majoritaire et grandissant de cas, le « bon programmeur » est moins celui qui écrit du code astucieux (l'optimiseur s'en chargera le plus souvent mieux que lui) que celui qui écrit du code lisible et aisé à maintenir. Une bonne connaissance des techniques de structures de données ainsi que des algorithmes (même sans aller jusqu'aux considérations théoriques poussées de la complexité algorithmique) se montre bien plus féconde que celle d'un langage d'assemblage. Lorsqu'on a déterminé l'algorithme le plus adéquat, les optimisations les plus efficaces peuvent être obtenues en utilisant le chemin suivant :
- écriture du code critique dans un langage de haut niveau (comme Scheme ou Common Lisp),
- application de transformations mathématiques successives qui préservent la spécification du programme tout en réduisant la consommation des ressources,
- traduction du code transformé dans un langage de bas niveau (langage C). Dans la pratique, les performances des machines actuelles font que des applications comportant beaucoup d'entrées-sorties peuvent faire l'économie de ces trois étapes et se rédiger directement dans un langage comme Haskell. L'application bien connue nget, qui moissonne systématiquement les images publiées dans les forums Usenet, avait dans sa première implémentation été écrite en Haskell. La version en C n'en a été qu'une traduction qui ne se révèle pas plus performante pour ce type d'application.
Optimisation automatique
Les compilateurs sont souvent capable de faire des optimisations locales, auxquelles aucun développeur ne penserait en première approche. Pour le langage C, cela peut considérer :
- les variables locales et les registres
- les fonctions non implémentées en assembleur en tant que fonction
- les switch, qui sont optimum.
Exemples

Une spécificité du binaire : le décalage
Une des toutes premières optimisations a été celle de la division et de la multiplication par une puissance de 2. En effet, l'informatique actuelle repose sur le binaire, puisqu'elle utilise comme élément de base le transistor (et historiquement, auparavant le relais) qui n'autorise que deux valeurs différentes. On a donc logiquement implémenté en langage machine les opérations de décalage à gauche et décalage à droite. En effet, en binaire, le décalage d'un nombre d'un cran vers la gauche le multiplie par 2. :Ainsi, 2 (10₂) décalé de 1 bit donne 4 (100₂). :5 (101₂) décalé de 2 bits donne 20 (10100₂) : $5 - 2^2=20$ . Ceci marche aussi pour la division, en décalant les bits vers la droite. :100 (1100100₂) décalé de 3 bits vers la droite donne $100/2^3=12.5$ donc 12 (1100₂) car nous travaillons sur des nombres entiers. La division (en dehors de ce cas et des cas pathologiques) est une instruction coûteuse en temps machine, et n'est d'ailleurs toujours pas disponible sur la grande majorité des processeurs de type RISC.

Le mot clef inline du C

Le code C suivant: inline int f(int a, int b) int g (int a) Une compilation avec gcc -O4 -S donne: .file "opt.c" .text .p2align 4,,15 .globl g .type g, @function g: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx cmpl $12, %edx jg .L14 leal -2(%edx), %eax cmpl $11, %edx jge .L15 movl $100, %eax cmpl $10, %edx .L17: je .L2 movl %edx, %eax .L15: imull %edx, %eax .L2: popl %ebp ret .p2align 4,,7 .L14: movl $1437600, %eax cmpl $1200, %edx jmp .L17 .size g, .-g .section .note.GNU-stack,"",@progbits .ident "GCC: (GNU) 3.3.2 (Mandrake Linux 10.0 3.3.2-6mdk)" Ce qui pourrait se traduire, pour une compréhension plus aisée, par le code C suivant: int g(int a) On peut remarquer par exemple que la fonction 'f' n'a pas été générée, mais que son code a directement été incorporé dans la fonction 'g' (le mot clef 'inline' permet de forcer ce type d'optimisation en C ) Catégorie:Programmation informatique

Tests unitaires

Catégorie:Génie logiciel Catégorie:Gestion de projet En programmation, les tests unitaires sont un type de test effectué sur un logiciel ou un programme et une des phases du cycle en V Il s'agit pour le programmeur de tester un seul module logiciel, indépendamment du reste du programme, afin de s'assurer qu'il répond aux spécifications fonctionnelles et qu'il fonctionne correctement en toutes circonstances. Cette vérification est essentielle dans les applications critiques, et peut s'accompagner d'une vérification de la couverture de code, c'est-à-dire que le test passe dans la totalité (ou une fraction de la totalité) des branchements possibles. Le test unitaire doit être rejoué après une modification du code afin de vérifier qu'il n'y a pas de régressions (l'apparition de nouveaux dysfonctionnements). Dans les applications non critiques, l'écriture des tests unitaires a longtemps été considérée comme une tâche secondaire. Cependant, la méthode EXtreme Programming (XP) a remis les tests unitaires, qu'elle nomme maintenant Tests du Programmeur, au centre de l'activité de programmation. La méthode XP préconise d'écrire les tests en même temps, ou même avant la fonction à tester. Ceci permet de définir précisément l'interface du module à développer. En cas de découverte d'un bogue logiciel, on écrit la procédure de test qui reproduit le bogue. Après correction on relance le test, qui ne doit indiquer aucune erreur. Tout un environnement préparé (framework) existe dans différents langages informatiques pour réaliser facilement des tests unitaires, citons [http://junit.org JUnit] pour Java, DUnit pour Delphi, etc.

Exemple

En pascal, soit une fonction (très basique pour rester clair) où on veut récupérer la somme des 2 paramètres multipliée par 2 (il y a volontairement une erreur) : function Somme(a, b : integer) : integer; begin Result := a + b
- 2; end; On va écrire la fonction de test procedure TEST_somme; begin CheckEquals(Somme(0, 0), 0); // On s'attend à avoir 0 CheckEquals(Somme(1, 0), 2); // On s'attend à avoir 2 CheckEquals(Somme(0, 1), 2); // On s'attend à avoir 2 aussi CheckEquals(Somme(1, 1), 4); // On s'attend à avoir 4 CheckEquals(Somme(2, 1), 6); // On s'attend à avoir 6 end; On déroule le test, et il nous signale une erreur dans la fonction. Pour Somme(1, 0), il s'attend à avoir 2 et il obtient 1 ! On corrige donc la fonction : function Somme(a, b : integer) : integer; begin Result := (a + b)
- 2; end; Et en déroulant le test, on a ce coup-ci 0 erreur.

Contrôle de version

La gestion de version (en anglais revision control) est une activité qui consiste à maintenir l'ensemble des versions d'un logiciel. Essentiellement utilisée dans le domaine de la création de logiciels, elle est surtout concernée par le code source ; mais elle peut être utilisée pour tout type de document informatique. Cette activité étant fastidieuse et relativement complexe, un appui logiciel est presque indispensable. À cet effet, il existe différents logiciels de gestion de version qui, bien qu'ayant des concepts essentiels communs, apportent chacun son propre vocabulaire et ses propres usages. À titre d'exemple, on trouve un mécanisme de gestion de version dans Wikipedia : pour chaque article, l'historique est disponible en cliquant sur le lien [http://fr.wikipedia.org/w/wiki.phtml?title=Contr%F4le_de_version&action=history Historique].

Les versions

Les logiciels évoluant, chaque étape d'avancement est appelée version. Les différentes versions sont nécessairement liées à travers des modifications. Une modification peut correspondre à des ajouts, modifications, suppressions ou une combinaison des trois sur une version donnée. Schématiquement, on passera de la version N à la version N + 1 en appliquant une modification M. Un logiciel de gestion de versions nous aidera alors à soustraire la modification M à la version N + 1 pour retrouver la version N. Il est à noter que les concepteurs du logiciel de gestion de versions CVS ont choisi de parler de « révisions » (revisions) afin de ne pas confondre la version du logiciel avec les « révisions » de ses fichiers sources. Pour des raisons pratiques, on associe généralement un « numéro » à une version (voir Version d'un logiciel).

Modifications et ensemble de modifications

Une modification constitue donc l'évolution entre deux versions. On peut donc aussi bien parler de la différence entre deux versions que de modification ayant amené à une nouvelle version. On utilise généralement la gestion de version à un ensemble de fichiers qui constitue un projet. De ce fait, il est courant de parler de modification pour un seul fichier et d'ensemble de modifications (change set) lorsqu'il s'agit du projet (et donc de plusieurs fichiers). En effet, les deux n'évoluent pas au même rythme. Pour illustrer, prenons l'exemple d'un logiciel nommé « Toto ». Il est constitué des fichiers A, B et C. À la version 1.0 de « Toto » correspondent les versions 1.0 de chacun des fichiers. Admettons que l'ajout d'une fonctionnalité à « Toto » impose la modification de A et de C. Présentons la situation à l'aide d'un tableau Du point de vue du projet, les modifications apportées à A et à C font partie du même ensemble.

Branches

Des modifications divergentes peuvent intervenir sur un ensemble de fichiers. On parle alors de branches. Parfois il s'agit aussi de faire converger des branches. On parle alors de fusion de branches.

Conflit de modifications

Dans le cas d'une gestion de version en équipe, chacun travaille de façon indépendante, donc sur des branches de versions différentes. Les fusions régulières sont nécessaires à un avancement global du logiciel. Il n'est pas rare que, suite à une mauvaise communication au sein de l'équipe, certaines modifications soient contradictoires (par exemple lorsque deux personnes ont apporté des modifications différentes à la même partie d'un fichier). On parle alors de conflit (de modifications) puisque le logiciel de gestion de version n'est pas en mesure de savoir laquelle des deux modifications appliquer.

Systèmes centralisés et décentralisés

CVS et Subversion sont des logiciels centralisés, ce qui veut dire qu'il n'existe qu'un seul dépôt des fichiers, dépôt qui fait référence. Cela peut simplifier le modèle mais cela est contraignant pour certains usages (travail sans connexion au réseau ou tout simplement travail sur des branches expérimentales ou bien contestées). Il existe donc également des logiciels décentralisés comme Mercurial ou darcs. Avec ceux-ci, il existe plusieurs dépôts dont aucun n'a de statut privilégié.

Fonctionalités notoires des logiciels de gestion de version

Étiquetage ou marquage

Cela consiste à associer un nom à une version donnée. Pour certains outils de gestion de version (comme CVS) qui gèrent les versions à une faible granularité (beaucoup de modification non significatives), c'est un moyen de retrouver facilement une version significative.

Comparaison

Il est possible de comparer plusieurs versions pour en extraire les modifications.

Verrouillage et notifications

Pour le travail en équipe, certains logiciels de gestion de version apportent des outils pour communiquer. Par exemple, le verrouillage permet d'interdire la modification d'un fichier, tandis que la notification émet un avertissement à tous les autres membres lorsqu'un fichier est modifié.

Exemples de logiciels de gestion de version

Les logiciels de contrôle de version sont nombreux. Sous UNIX il y a eu SCCS qui a suscité un logiciel libre alternatif : RCS (Revision Control System) qui est devenu un standard de fait. Comme RCS ne gérait que des fichiers individuels, nombre de ses utilisateurs ont créé des surcouches gérant les arborescences de fichiers. Certaines de ces surcouches furent distribuées librement. Il en fut ainsi de PRCS et de CVS. CVS est devenu extrêmement répandu dans le monde du logiciel libre sur Internet, mais aussi dans les entreprises. CVS est simple à mettre en œuvre et offre les fonctionnalités fondamentales qu'attendent ses utilisateurs. Mais l'histoire des logiciels de contrôle de version ne s'arrête pas en 2002 et de nouveaux logiciels libres concurrencent CVS, comme par exemple Subversion, darcs et GNU Arch. Dans le monde propriétaire, Visual Source Safe (de Microsoft) est largement utilisé, notamment du fait de son intégration avec l'outil de développement Visual Studio, malgré de nombreuses lacunes et des mises à jour peu fréquentes.

Voir aussi

- Logiciel de gestion de versions
- Gestion de configuration
- Version d'un logiciel Catégorie:Programmation informatique Catégorie:Gestion de projet Catégorie:Gestionnaires de versions ja:バージョン管理システム

Gantrischregion

Der Gantrisch ist ein 2175 m hoher Berg im Berner Oberland in der Schweiz. Direkt östlich neben dem Gantrisch befindet sich der Gipfel der Nünenflue (2102 m ü. M.); die Lücke dazwischen heißt Leiterepass. Und etwas westlich davon befindet sich der Ochsen, welcher mit 2188 m ü. M. etwas höher ist, doch ist der Gantrisch der bekannteste Gipfel in dieser Region und gibt ihr ihren Namen. An das Gantrischgebiet schließt im Osten die Stockhornkette an und im Norden das Gurnigelgebiet. Im Süden befindet sich das Simmental; im Westen das obere Sensegebiet. Mit seiner unberührten Natur ist das Gantrischgebiet ein beliebtes Wander- und Skitourengebiet. Kategorie:Berg in der Schweiz Kategorie:Zweitausender Kategorie:Alpen Kategorie:Geographie (Kanton Bern)

webmaster nauka elitarne.info oszust online casinos

:: RELATED NEWS ::