Langage de programmation ko:프로그래밍 ja:プログラミング
La programmation dans le domaine informatique est l'ensemble des activités qui permettent l'écriture des programmes informatiques. C'est une étape importante de la conception de logiciel (voire de matériel, cf. VHDL).
Pratiques
- Algorithmique
- Codage
- Contrôle de version
- Optimisation du code
- Programmation système
- Refactoring
- Test unitaisre
Techniques de programmation
- Programmation impérative
- Programmation orientée objet
- Programmation par contrat
- Programmation déclarative
- Programmation fonctionnelle
- Programmation logique
- Programmation par contraintes
- Programmation orientée composant
- Programmation orientée aspect
- Programmation concurrente
Langages de programmation
Les langages de programmation permettent de définir les ensembles d'instructions effectuées par l'ordinateur lors de l'exécution d'un programme. Il existe des milliers de langages de programmation, la plupart d'entre eux étant réservés à des domaines spécialisés. Ils font l'objet de recherches constantes dans les universités et dans l'industrie.
Les langages de programmation peuvent être classifiés de nombreuses manières : généraliste/spécialisé, haut niveau/bas niveau, interprété/compilé, avec ou sans gestion de mémoire automatisée, système de gestion d'exceptions, typage fort/typage faible, typage statique/typage dynamique, syntaxe fixe/extensible ; non objet/orienté objet/purement objet, impératif/fonctionnel/déclaratif, fonctionnel pur/impur, etc.
Nous incluons ci-dessous une classification sommaire des langages de programmation les plus connus. Il faut garder à l'esprit que de nombreux langages appartiennent simultanément à plusieurs catégories - ils sont dits « multi-paradigmes ».
Par exemple, C++ permet la programmation impérative, orientée objet et la programmation générique (à base de classes et de fonctions paramétrées nommées templates). Common Lisp est à la fois impératif, fonctionnel, orienté objet -- et de par son caractère « programmable » (un langage de programmation programmable...), il peut intégrer d'autres « paradigmes » de programmation en son sein (par exemple la programmation logique, ou par contraintes).
Ci-dessous, nous listons les langages les plus connus (nous mettons entre parenthèses certains langages dérivés ou les extensions requises).
Langages déclaratifs
- Oz
- Mercury
- Prolog pour PROgrammation LOGique
- Clips
Ci-dessous, nous listons les langages spécialisés, c'est-à-dire dont l'utilisation est réservée à des domaines bien spécifiques ; les plus connus sont :
Langages de définition de données
- ASN.1
- DTD SGML
- DTD XML
- XML Schéma
- Relax NG
Langages spécialisés pour la communication avec une base de données
- 4GL
Langages de manipulation de chaînes de caractères
- SNOBOL StriNg Oriented symBOlic Language (Langage Symbolique Orienté Chaînes de Caractères)
- awk
- Perl
- sed
Langages spécialisés Web
- Exécution par le serveur HTTP (côté serveur) :
- ASP
- JSP (issu de Java, basé sur des Servlets)
- PHP
- XSP (issu de XML, soutenu par Apache)
- D'une manière générale, les langages non spécialisés (notamment Perl et C) peuvent également être utilisés via Common Gateway Interface
- Exécution par le navigateur Web (côté client) :
- JavaScript ou ECMAScript
- VBScript
- applets écrites en Java
- ActionScript de Macromedia Flash
Langages de description de page
voir Langage de balisage
Langages de programmation théorique
- Lambda-calcul
- Pi-calcul
- Join-Calcul
- Récursion Primitive
- Système T de Kurt Gödel
- BNF
Langages de programmation de Commande Numérique (C.N.)
Une machine-outil automatisée, ou Commande Numérique (C.N.), a besoin d'un langage de programmation pour réaliser les opérations de tournage, ou de fraisage…
- Programmation de Commande Numérique
Pour rendre la programmation plus difficile
- Brainfuck (ou encore F - ckF - ck, Ook ou spoon)
- Intercal
- Malbolge
- Unlambda
Non classés
- Nosica
- SAS
- Langage K
- GOTO++
Langages spécialisés
- ABEL : langage pour la programmation électronique des PLD
- R : langage pour l'outil de statistiques du même nom
- VHDL : langage de description matérielle, permettant de synthétiser de l'électronique numérique (descriptions de portes logiques)
- VRML : description de scènes en trois dimensions
- Allegro - multi-plateforme, Multimédia, Jeux
- DirectX - 3D, Multimédia
- GTK+ - multi-plateforme, Environnement graphique
- JFC - Environnement graphique, 2D
- OpenGL - 3D
- Qt - multi-plateforme, Interface utilisateur
- Quartz - Environnement graphique
- SDL - Video
- SWT - multi-plateforme, Interface utilisateur
- Tk - multi-plateforme - Interface graphique associée à Tcl
- wxWidgets - multi-plateforme - Environnement graphique
- Xlib - 2D
Voir aussi
Liens internes
- Chronologie des langages de programmation
- [http://fr.wikibooks.org/wiki/Programmation Wikilivre sur la programmation]
- ABAP
- RIP
Liens externes
- [http://www.codes-sources.com/ CodeS-SourceS ] : site de passionnés qui partagent leurs connaissances
- [http://www.developpez.com/ Developpez.com, le club des développeurs] (de nombreux forums, cours et tutoriels de programmation)
- [http://www.levenez.com/lang/ Computer Languages History]
- [http://www.techbooksforfree.com/perlpython.shtml Free Python Books]
- [http://www.a525g.com/programmation/index-fr.htm A525G - Programmation]
- [http://www.99-bottles-of-beer.net/ 99 Bouteilles de Bière - Un même programme en plus de 780 langages]
- [http://coding.romainl.com Programmation Network Security]
- [http://rmdiscala.developpez.com/cours/ Package pédagogique multimédia V4.1]
Catégorie:Programmation informatique
Informatique ko:컴퓨터 과학 ja:情報工学 simple:Computer science th:วิทยาการคอมพิวเตอร์ zh-cn:计算机科学 zh-tw:計算機科學
oc:informatica]
Etymologiquement, Le terme informatique désigne l'automatisation du traitement de l'information par une machine (virtuelle ou physique). Dans son acception courante, l'informatique désigne de façon vague l'ensemble des sciences et techniques en rapport de près ou de loin avec l'information et l'ordinateur. Par exemple, l'informatique désigne aussi bien le matériel informatique que la conception et l'administration de la partie immatérielle d'un ordinateur : les logiciels.
La traduction anglaise étymologique serait informatics, mais l' usage tant en français qu'en anglais fait qu'une meilleure traduction serait probablement computer science, bien que ce terme fasse peut-être référence de façon plus explicite à ce que l'on pourrait appeler informatique fondamentale ou informatique scientifique. En anglais les termes distincts suivants sont utilisés :
- L'informatique fondamentale (Computer Science), ce qui ressort de l' épistémologie procédurale, soit notamment de l'étude des algorithmes, et donc indirectement des logiciels et des ordinateurs.
- L'ingénierie informatique (Computer Engineering), ce qui ressort de la fabrication et de l'utilisation du matériel informatique.
- L'ingénierie logicielle (Software Engineering), ce qui ressort de la modélisation et du développement des logiciels; ceci comprend le traitement des données (Data Processing), ce qui est du domaine de la mise en pratique des traitements de données.
- L'évolution des techniques et des technologies reliées à l'informatique (Information Technology).
Des professions aussi diverses que concepteur, développeur, responsable d'exploitation, ingénieur système, technicien de maintenance, matérielle ou logicielle, chercheur en informatique ou directeur d'un centre de calcul, relèvent du domaine de l'informatique. Néanmoins, le terme informaticien désigne le plus souvent ceux qui conçoivent, déploient et mettent en œuvre des solutions.
Étymologie
Le terme informatique a été créé en mars 1962 par Philippe Dreyfus à partir des mots «information» et «automatique». Il donna ce nom à l'entreprise qu'il venait de fonder, la Société d'Informatique Appliquée, sans breveter le mot informatique.
En France, l'usage officiel du mot a été consacré par Charles de Gaulle qui, en Conseil des ministres, a tranché entre «informatique» et «ordinatique», et le mot fut choisi par l'Académie française en 1967 pour désigner cette nouvelle discipline. En juillet 1968, le ministre fédéral de la Recherche scientifique d'Allemagne, Gerhard Stoltenberg, prononça le mot informatik lors d'un discours officiel au sujet de la nécessité d'enseigner cette nouvelle discipline dans les universités de son pays, et c'est ce mot qui servit aussitôt à nommer certains cours dans les universités allemandes. Le mot informatica fit alors son apparition en Italie et en Espagne, de même quinformatics au Royaume-Uni.
Pendant le même mois de mars 1962 Walter F. Bauer inaugura la société américaine Informatics Inc., qui elle breveta son nom et poursuivit toutes les universités qui utilisèrent ce nom pour décrire la nouvelle discipline, les forçant à se rabattre sur computer science, bien que les diplômés qu'elles formaient étaient pour la plupart des praticiens de l'informatique plutôt que des scientifiques au sens propre. L'Association for Computing Machinery, la plus grande association d'informaticiens au monde, approcha même Informatics Inc. afin de pouvoir utiliser le mot informatics pour remplacer l'expression computer machinery, mais l'entreprise déclina l'offre. La société Informatics Inc. cessa ses activités en 1985, achetée par Sterling Software.
Histoire
Voir l'article détaillé : Histoire de l'informatique
Les origines
Depuis des millénaires, l'Homme a créé et utilisé des outils l'aidant à calculer (abaque, boulier, etc.). Les premières machines mécaniques apparaissent entre le XVIIe et le . La première machine à calculer mécanique réalisant les quatre opérations aurait été celle de Wilhelm Schickard au , mise au point notamment pour aider Kepler à établir les tables rudolphines d'astronomie.
En 1642, Blaise Pascal réalisa également une machine à calculer mécanique qui fut pour sa part commercialisée et dont neuf exemplaires existent dans des musées comme celui des Arts et métiers et dans des collections privées (IBM).
La découverte tardive du mécanisme d'Antikhitère montre que les Grecs de l'Antiquité eux-mêmes avaient commencé à réaliser des mécanismes de calcul en dépit de leur réputation de mépris général pour la technique (démentie d'ailleurs par les travaux d'Archimède).
Cependant, il faudra attendre la définition du concept de programmation (illustrée en premier par Joseph Marie Jacquard avec ses métiers à tisser à cartes perforées, suivi de Boole et Ada Lovelace pour ce qui est d'une théorie de la programmation des opérations mathématiques) pour disposer d'une base permettant d'enchaîner des opérations élémentaires de manière automatique.
L'informatique moderne
L'ère des ordinateurs modernes commença avec les développements de l'électronique pendant la Seconde Guerre mondiale, ouvrant la porte à la réalisation concrète de machines opérationnelles. Au même moment, le mathématicien Alan Turing théorise le premier ce qu'est un ordinateur, avec son concept de machine universelle de Turing.
L'informatique est donc un domaine fraichement développé, même s'il trouve ses origines dans l'antiquité (avec la cryptographie) ou dans la machine à calculer de Blaise Pascal, au . Ce n'est qu'à la fin de la Seconde Guerre mondiale qu'elle a été reconnue comme une discipline à part entière et a développé des méthodes, puis une méthodologie qui lui étaient propres.
Son image a été quelque temps surfaite : parce que les premiers à programmer des ordinateurs avaient été des ingénieurs rompus à la technique des équations différentielles (les premiers ordinateurs, scientifiques, étaient beaucoup utilisés à cette fin), des programmeurs sans formation particulière, parfois d'ailleurs issus de la mécanographie, cherchaient volontiers à bénéficier eux aussi de ce label de rocket scientist afin de justifier des salaires rendus confortables par :
- le prix élevé des ordinateurs de l'époque (se chiffrant en ce qui serait des dizaines de millions d'euros aujourd'hui compte-tenu de l'inflation, il reléguait au second plan les considérations de parcimonie sur les salaires) ;
- l'aspect présenté comme peu accessible de leur discipline et un mythe de difficulté mathématique entretenu autour. En fait, les premiers ordinateurs ne se programmaient pas de façon très différente de celle des calculatrices programmables utilisées aujourd'hui dans les lycées et collèges, et maîtrisées par des élèves de quatorze ans mais le domaine était nouveau et l'algorithmique nécéssite un certain degré de concentration associé, peut-être à tort, à la réflexion pure.
L'émergence d'un aspect réellement scientifique dans la programmation elle-même (et non dans les seules applications scientifiques que l'on programme) ne se manifeste qu'avec la série The Art of Computer Programming de Donald Knuth, professeur à l'Université de Stanford, à la fin des années 1960, travail monumental encore inachevé en 2004. Les travaux d'Edsger Dijkstra, Niklaus Wirth et Christopher Strachey procèdent d'une approche également très systématique et elle aussi quantifiée.
On demandait à Donald Knuth dans les années 1980 s'il valait mieux selon lui rattacher l'informatique (computer science) au génie électrique — ce qui est souvent le cas dans les universités américaines — ou à un département de mathématiques. Il répondit : «Je la classerais volontiers entre la plomberie et le dépannage automobile» pour souligner le côté encore artisanal de cette jeune science.
Toutefois, la forte scientificité des trois premiers volumes de son encyclopédie suggère qu'il s'agit là plutôt d'une boutade de sa part. Au demeurant, la maîtrise de langages comme Haskell ou même APL demande un niveau d'abstraction tout de même plus proche de celui des mathématiques que des deux disciplines citées.
La miniaturisation des composants et la réduction des coûts de production, associées à un besoin de plus en plus pressant de traitement des informations de toutes sortes (scientifiques, financières, commerciales...) a entraîné une diffusion de l'informatique dans toutes les couches de l'économie comme de la vie de tous les jours.
Approche fonctionnelle
Comme énoncé ci-dessus, l'informatique est le traitement automatisé de données par un appareil électronique : l'ordinateur ; les germanophones parlent de elektronisch Daten Verarbeitung / EDV (« traitement électronique de données »), les anglophones dinformation technology / IT (« technologies de l'information »), c'est-à-dire :
- données ou informations : in fine, l'ordinateur manipule des nombres (d'où le terme anglais computer, littéralement « calculateur »), mais ces nombres peuvent représenter divers types d'informations :
- des... nombres bien évidemment, dans le cas de calculs scientifiques (flottants) ou comptables (décimal, ou binaire entier)... ;
- un texte, des lettres (caractères), que l'on peut mettre en forme avec un traitement de texte, imprimer, envoyer par courrier électronique... ;
- du dessin vectoriel (CAO, logiciels d'illustration, et de typographie) ;
- des images statiques (photographies) ou animées (vidéo), des hologrammes ;
- des sons, enregistrés (technique du direct to disk) ou bien fabriqués par l'ordinateur (synthétiseur), que ce soient des bruitages, de la musique (cf. musique et informatique) ou de la parole ;
:la conversion de ces informations en suite de nombres pose le problème du format des données, du codage et des formats normalisés (par exemple, représentations des nombres entiers ou à virgule flottante, format ASCII, Unicode, TeX ou RTF et polices PostScript ou TrueType pour les textes, formats bitmap, TIFF, JPEG, PNG, etc. pour les images fixes, formats QuickTime, MPEG pour les vidéos, interface MIDI pour la musique...).
- automatisé : l'utilisateur n'intervient pas, ou peu, dans le traitement des données ; le traitement est défini dans un programme qui se déroule tout seul, l'utilisateur se contente de fournir des paramètres de traitement ; le programme automatique se déroule selon un algorithme, l'établissement de ce programme est le domaine de la programmation.
- traitement : ces données sont :
- créées :
- nombres : acquisition automatique de données d'une expérience avec un ordinateur ;
- texte : taper un texte au clavier ;
- images : dessins réalisés à la souris ou sur une tablette graphique, synthèse d'image (pour présenter un projet – objet fictif en cours de conception –, imagerie médicale, dessin artistique – infographie –, film d'animation ou pixilation) ou numérisation d'une image existante (scanner, appareil photographique numérique) ou d'images animées (caméra numérique, webcam) ;
- sons enregistrés (microphone) ou recréés à partir d'une partition virtuelle (synthétiseur) ou d'un texte (synthèse vocale).
- analysées :
- nombres : l'analyse des nombres relève du domaine concerné (mathématiques, physique, économie...) ;
- texte : rechercher les occurrences de mots dans un texte pour en tirer des statistiques, aide à la correction orthographique et/ou grammaticale, et, plus généralement, traitement automatique des langues (TAL) ;
- images : on peut vouloir identifier un objet (reconnaissance de forme, reconnaissance des caractères ou OCR), ou bien déterminer la surface couverte par une couleur (par exemple pour quantifier une surface recouverte) ;
- sons : analyse spectrale, reconnaissance vocale.
- modifiées :
- nombres : calculs ;
- texte : modification d'un texte existant, traduction automatique dans une autre langue (ou langage de programmation) ;
- images : modification du contraste, de la luminosité, des couleurs, effets spéciaux ;
- sons : application d'effets (réverbération, distorsion, ajustement de la hauteur) ;
::comme il existe, selon les programmes et les besoins, une grande variété de codages possibles pour représenter chaque type d'information, beaucoup de traitements consistent à convertir les données d'un format vers un autre...
- archivées puis restituées :
- les moyens et techniques d'archivage varient en fonction de la durée de conservation souhaitée et des quantités de données en jeu : mémoires électroniques, bandes magnétiques, disques magnétiques ou optiques ;
- les moyens de restitution dépendent de la nature des données : écrans ou imprimantes pour le texte et les images, haut-parleurs ou instruments MIDI pour les sons...
Approche organisationnelle
L'informatique pour l'organisation est un élément d'un système de traitement d'information (les entrées peuvent être des formulaires papier par exemple) et d'automatisation. Depuis Henry Ford, l'automatisation des tâches ayant été identifiée comme un avantage concurrentiel, la question est : que peut-on automatiser ?
Autant il est relativement facile d'automatiser des tâches manuelles, autant il est difficile d'automatiser le travail intellectuel et parfois créatif. L'approche de l'informatique dans une organisation commence donc par l'élucidation des processus, c'est-à-dire modéliser le métier. Après validation, la MOA (Maîtrise d'Ouvrage) fournit les spécifications fonctionnelles de (l'ouvrage) qui vont servir de référence dans la conception pour la MOE (Maîtrise d'œuvre).
Cette conception sera alors effectuée dans le respect d'un Cycle de développement qui définit les rôles et responsabilités de chaque acteur. Ainsi, les échanges entre MOA et MOE ne se résument pas à la maîtrise des chantiers (tenue des délais et des coûts, et validation des livrables), la MOA et la MOE sont garantes (éventuellement responsables sur un plan juridique) de la cohérence des systèmes d'information, et de l'adéquation des solutions informatiques avec les problèmes utilisateurs finaux initialement constatés.
Matériel
Article détaillé : Matériel informatique
On utilise également le terme anglais hardware (littéralement « quincaillerie ») pour désigner le matériel informatique. Il s'agit de tous les composants que l'on peut trouver dans :
1. Les ordinateurs et leurs périphériques : un ordinateur est un ensemble de circuits électroniques permettant de manipuler des données sous forme binaire, représentées par des variations de signal électrique. Il existe différents types d'ordinateurs :
ordinateur 5150 datant de 1981, Système d'exploitation IBM-DOS 2.0]]
- Les micro-ordinateurs.
De bureau ou portables. Ils sont composés d'une unité centrale : un boîtier contenant la carte mère, l'alimentation, des unités de stockage. On y ajoute une console : un écran et un clavier. Divers périphériques peuvent leur être ajoutés, une souris, une imprimante, un scanner..ect;
scanner
- Les stations de travail.
Des micro-ordinateurs particulièrement puissants et chers, utilisés uniquement pour des besoins professionnels pointus (conception assistée par ordinateur). Ce terme était particulièrement en vogue dans les années 1980-1990. Depuis les années 2000, il n'est guère possible de concevoir une station de travail plus puissante qu'un micro-ordinateur haut de gamme ;
- Les mainframes.
Une armoire abrite l'unité centrale et l'alimentation, une ou plusieurs autres les périphériques de stockage (disque dur, sauvegarde) tandis que les moyens de communication et réseau (routeur, hubs, modem) sont dans la même pièce, mais dans des racks séparés. Une console d'administration (écran, clavier, imprimante) est généralement située dans ce même local ;
administration]
- Les PDA (Personal Digital Assistant, encore appelés organiseurs).
Ce sont des ordinateurs de poche proposant des fonctionnalités liées à l'organisation personnelle (agenda, calendrier, carnet d'adresse, etc.). Ils peuvent être reliés à Internet par différents moyens (réseau Wifi, Bluetooth, etc.).
- Et bien d'autres appareils.
Dans le domaine de l'informatique embarquée : téléphone, électroménager, automobile, armements militaires, etc.
Les cartes à puces, ou l'informatique industrielle.
Logiciel
Le logiciel désigne la partie à première vue immatérielle de l'informatique, l'organisation et le traitement de l'information : les programmes. On s'est en effet vite rendu compte que des machines techniquement très avancées pour leur époque, comme la Bull Gamma 60, restaient invendables tant qu'on n'avait pas de programmes à livrer pour les rendre immédiatement opérationnelles. IBM lança entre 1968 et 1973 une sorte d'ancêtre du logiciel libre avec son ordinateur 1130, politique qui assura à celui-ci par effet boule de neige un succès immédiat et planétaire, mais les conclusions d'un procès antitrust lui interdirent de distribuer bénévolement du logiciel.
Le monde des mainframes classe les logiciels en catégories suivantes :
- systèmes d'exploitation ;
- bases de données, comme DB2, Ingres ou Oracle ;
- programmes de communication, comme NCP ou RSCS ;
- moniteurs de télétraitement ;
- systèmes transactionnels, comme CICS ;
- systèmes de temps partagé, utilisés pour le calcul ou le développement ;
- compilateurs traduisant les langages en instructions machine et appels système ;
- tout le reste entrait en une catégorie nommée Logiciels applicatifs.
Plus simplement on distingue généralement trois types de logiciels (par ordre de proximité du matériel) :
- le firmware
- le système d'exploitation
- les logiciels et applications utilisateur (en anglais software)
On classe aussi les logiciels en libre et propriétaire, bien que les deux soient parfois panachés à des degrés divers. Certains ont une fonction bureautique ou multimédia comme par exemple les jeux vidéo. Certains logiciels ont acquis des noms connus de tous.
Le noyau du système d'exploitation crée le lien entre le matériel et le logiciel. Un logiciel, quand il est fourni sous sa forme binaire, serait utilisable uniquement avec un système d'exploitation donné (car il en utilise les services), et ne fonctionnerait que sur un matériel spécifique (car il en utilise le code d'instructions). Une conception plus récente, depuis le milieu de années 1980, consiste à distribuer les logiciels tous binaires confondus, et à les munir d'un système de licences par jetons ou tokens permettant l'usage de N copies simultanées du logiciel sur le réseau, tous matériels confondus. Cette approche est majoritaire dans le monde UNIX.
À l'initiative de Richard Stallman et du GNU, à partir de 1985, une mouvance de programmeurs refuse cette logique propriétaire et ceux-ci se muent en concepteurs inventifs pour se lancer dans le développement d'outils et de bibliothèques système libres compatibles avec le système UNIX. C'est pourtant le projet indépendant Linux, initié par Linus Torvalds, basé sur les travaux et les outils du GNU, qui aboutira dans la création d'un système d'exploitation complet et libre.
Une bonne partie des logiciels actuels fonctionnent dans un environnement graphique pour interagir avec l'utilisateur.
La diversité des systèmes informatiques a fait apparaître une technique visant à combiner le meilleur de chacun de ces univers : l'émulateur.
Il s'agit d'un logiciel permettant de simuler le comportement d'un autre système dans celui que l'on utilise,
- soit pour qu'une machine semble être une autre (voir IBM 1130),
- soit pour simuler le comportement d'un système d'exploitation (par exemple DOS ou Windows sous Linux).
Le terme anglais est software, à l'origine un jeu de mot entre hardware (« quincaillerie », pour désigner le matériel) et l'opposition soft/hard (mou/dur), opposition entre le matériel (le dur) et l'immatériel (le mou). Les traductions françaises matériel et logiciel rendent parfaitement cette opposition et cette complémentarité.
Le logiciel réalise normalement une fonction attendue de ses utilisateurs. Néanmoins, des effets secondaires (parfois nommés par contresens de traduction effets de bord) existent. Parfois même, certains logiciels sont destinés à nuire, comme les virus informatiques, nommés en anglais, par analogie avec software : malware (qu'on pourrait traduire par le néologisme nuisiciel, ou logiciel malveillant).
La création des logiciels
Un projet informatique s'inscrit dans un cycle de développement qui définit les grandes étapes de la réalisation (planification), de la manière dont on passe d'une étape à l'autre (modèle incrémental, en V, en spirale, etc.). Pour les petits projets (ou les petites équipes de développement), cette réflexion est souvent négligée (on se répartit les modules et chacun développe dans son coin). Ceci est une cause fréquente d'erreurs (bogues) et de non-conformité (le produit final n'est pas conforme aux attentes de l'utilisateur). Mais même les énormes projets, avec beaucoup de moyens, sont victimes de cette négligence ; ainsi, l'échec du premier vol d'Ariane 5 fut dû à un problème de logiciel, etc. Un projet peut alors intégrer une approche de la qualité et de la sûreté de fonctionnement des systèmes informatiques afin de contrôler autant que possible le produit final.
Un projet comprend les étapes suivantes :
- l'établissement d'un cahier des charges qui définit les spécifications auxquelles devra répondre le logiciel ;
- la définition de l'environnement d'exécution (architecture informatique) :
- type(s) d'ordinateur sur lequel le logiciel doit fonctionner (station de calcul, ordinateur de bureau, ordinateur portable, assistant personnel, téléphone portable, guichet automatique de banque, ordinateur embarqué dans un véhicule ;
- type et version du(des) système(s) d'exploitation sous-jacent ;
- périphériques nécessaires à l'enregistrement des données et à la restitution des résultats (capacité de stockage, mémoire vive, possibilités graphiques...) ;
- nature des connexions réseau entre les composants (niveau de confidentialité et de fiabilité, performances, protocoles de communication...) ;
- la conception de l'application et de ses constituants, et notamment de l'interactivité entre les modules développés : structure des données partagées, traitement des erreurs générées par un autre module... : c'est le domaine du génie logiciel ;
- la mise en place d'une stratégie de développement :
- répartition des tâches entre les développeurs ou les équipes de développement, qui vont assurer le codage et les tests ;
- le plan de test du logiciel, pour s'assurer qu'il remplit bien la mission pour laquelle il a été écrit, dans toutes les conditions d'utilisation qu'il pourra normalement rencontrer, mais aussi dans des cas limites.
Après chacune de ces phases, on peut avoir une étape de recette, où le client va valider les choix et les propositions du maître d'œuvre.
La phase de programmation consiste à décrire le comportement du logiciel à l'aide d'un langage de programmation. Un compilateur sert alors à transformer ce code écrit dans un langage informatique compréhensible par un humain en un code compréhensible par la machine, le résultat est un exécutable. On peut également, pour certains langages de programmation, utiliser un interpréteur qui exécute un code au fur et à mesure de sa lecture, sans nécessairement créer d'exécutable. Enfin, un intermédiaire consiste à compiler le code écrit vers du bytecode. Il s'agit également d'un format binaire, compréhensible seulement par une machine, mais il est destiné à être exécuté sur une machine virtuelle, un programme qui émule les principales composantes d'une machine réelle. Le principal avantage par rapport au code machine est une portabilité théoriquement accrue (il « suffit » d'implanter la machine virtuelle pour une architecture donnée pour que tous les programmes en bytecode puissent y être exécutés), portabilité qui a fait, après sa lenteur, la réputation de Java. Il convient de noter que ces trois modes d'exécution ne sont nullement incompatibles. Par exemple, OCaml dispose à la fois d'un interpréteur, d'un compilateur vers du bytecode, et d'un compilateur vers du code natif pour une grande variété de processeurs. Une fois écrit (et compilé si nécessaire), le code devient un logiciel.
Pour des projets de grande amplitude, nécessitant la collaboration de beaucoup de programmeurs, voire de plusieurs équipes, on a souvent recours à une méthodologie commune (par exemple MERISE) pour la conception et à un atelier de génie logiciel (AGL) pour la réalisation.
Au cours de la programmation et avant la livraison du produit final, le programme est testé afin de vérifier qu'il fonctionne bien (y compris dans des cas d'utilisation en mode dégradé) et qu'il est conforme aux attentes de l'utilisateur final. Les tests intermédiaires permettent de s'assurer que chaque module de code réalise correctement une fonction : ce sont les tests unitaires. Les tests finals qui vérifient le bon enchaînement des modules et des traitements sont des tests d'intégration.
Pour certaines applications demandant un haut niveau de sûreté de fonctionnement, les tests sont précédés d'une étape de vérification, où des logiciels spécialisés effectuent (généralement sur le code source, mais parfois aussi sur le code compilé) un certain nombre d'analyses pour vérifier partiellement le bon fonctionnement du programme. Il n'est toutefois pas possible (et des théorèmes mathématiques montrent pourquoi), de garantir la parfaite correction de tout logiciel par ce moyen et la phase de test reste donc nécessaire. Elle se complète aussi, lorsqu'il s'agit d'une évolution d'une application existante, de nombreux tests automatisés de non-régression.
Statistiques : la création d'un logiciel est une tâche ardue ; environ 31 % des projets informatiques sont abandonnés avant d'être terminés, plus de 50 % des projets coûtent le double du coût initialement estimé et seulement 15 % des projets finissent dans les temps et selon le budget défini. Les besoins de seule maintenance de l'existant peuvent prendre jusqu'à 50 % des effectifs d'une équipe chargée d'un logiciel (or, c'est là une fonction pénible, ingrate, peu valorisante et qui rebute et démotive les bons programmeurs).
Traitement de l'information
L'information, pour être traitée, doit être :
- représentée par un codage :
- on utilise un système de numération binaire, où l'élément unitaire informationnel est le bit (contraction de l'anglais binary digit : chiffre binaire). Les bits sont généralement regroupés par huit, pour constituer des octets (ou bytes). Un octet peut être représenté par la séquence des bits qui le constituent (par exemple : 00101110) ou par une paire de valeurs hexadécimales (pour le même exemple : 2E), plus compact. Le choix du binaire ne résulte pas de la mystique, mais tout simplement d'utiliser de simples circuits de commutation, qui ont de très larges tolérances et par conséquent de faibles coûts ;
- on représente la structuration de l'information pour permettre des échanges entre composants logiciels et entre composants matériels. Pour cela, on définit des langages et des formalismes de représentation.
- stockée dans des systèmes permanents (mémoires dites de masse) ou non (mémoires dites volatiles).
Échanges de données : protocoles et normes
Les protocoles définissent une manière de procéder, notamment pour codifier la façon dont deux entités communiquent (modules ou couches logicielles, périphériques, etc.). On parle notamment de protocole de communication lorsqu'on veut définir des mécanismes de contrôle sur la manière dont l'échange d'information est réalisé.
Un protocole peut ainsi définir :
- un langage de description d'instructions et de données graphiques (exemple : AGP) ;
- un standard de commandes et de flux d'information pour une mémoire de masse (exemples : SCSI, FireWire, IDE, Serial ATA) ;
- des échanges entre le processeur et des cartes d'extension (exemples : PCI, PCI Express, ISA) ;
- des modalités de transfert d'information entre périphériques (exemple : USB) ou sur un réseau TCP/IP, Internet, ATM, X.25) ;
- des commandes entre un client et un serveur (exemples : POP3, IMAP, HTTP, FTP …) ;
- des échanges de données informatisés spécifiques (exemples : EDI, EAI, X.400, X.500).
Certains protocoles sont définis par des normes pour permettre l'interopérabilité des matériels ou de logiciels les mettant en œuvre. D'autres normes définissent, toujours dans le domaine de l'échanges de données :
- des langages de représentation d'information sans pour autant définir la manière dont cette information peut être échangée (exemples : ASN.1, XML) ;
- des architectures de réseaux (exemples : Modèle OSI, Wifi, Ethernet, Token-Ring).
Stockage des données
En matière de stockage d'information, on distingue le dispositif permettant de l'enregistrer physiquement (périphériques et composants) de la manière dont on structure et représente l'information pour faciliter son traitement.
Mémoire de masse
:Fichier de cartes perforées
:Bande magnétique
:Disque amovible magnétique (Disquette)
:Disque magnéto-optique
:Disque dur (disque magnétique embarquant le mécanisme, l'électronique et les têtes de lecture)
:Disque optique amovible (CD-ROM, CD-R, CD-RW mais aussi DVD-ROM, DVD-R, DVD-RW, DVD+R, DVD+R DL, DVD+RW, DVD-RAM, GD-ROM, HD-DVD, Blu-ray)
:Mémoire électronique non volatile (Mémoire flash, clé USB)
Mémoire volatile
:RAM
Organisation des données en vue du stockage
:Formats (extensions) de fichiers
:Système de fichiers
:Base de données
:Annuaire
Approches scientifiques
En dehors des aspects industriels et technologiques décrits jusqu'ici, l'informatique est une discipline scientifique à part entière.
:Algorithmique
:Algèbre de Boole
:Calculabilité
:Géométrie algorithmique
:Lambda-calcul
:Logique
:Model checking
:Théorie de l'information
:Théorie des graphes
:Théorie de la complexité
:Théorie de la calculabilité
:Théorie des automates finis
Applications
:Bio-informatique
:Calcul parallèle
:Cryptographie
:Exploration de données (data mining)
:Informatique grand système (mainframe)
:Informatique de gestion
:Informatique industrielle
:Informatique décisionnelle
:Imagerie Informatique
:Intelligence artificielle
:Interface homme-machine
:Micro-informatique
:Traitement du signal
:Hypermédias
:Informatique musicale
Annexes
- Informathèque
- Abréviations en informatique
- Dictionnaire informatique
- Informatique alternative
- Liste des articles d'informatique
- Personnes célèbres en informatique
- Revues informatiques sur papier
- Sécurité informatique
- Sites d'informations sur internet
- Terminologie de la distribution informatique
- Réseaux de neurones
- Musique et informatique
- Ordinateur quantique
- Hello_world
- Visual Information Exploration
-
Conception de logicielCatégorie:Programmation informatique
Catégorie:Gestion de projet Catégorie:Développement logiciel
La conception de logiciel met en œuvre tout un ensemble d'activités qui à partir d'une demande d'informatisation d'un processus (demande qui peut aller de la simple question orale jusqu'au cahier des charges complet) permettent la conception, l'écriture et la mise au point d'un logiciel (et donc de programmes informatiques) jusqu'à sa livraison au demandeur.
En règle générale, la conception de logiciel va suivre 3 grandes phases :
- Phase d'analyse (fonctionnelle) ou de conception Durant cette phase, on effectue simultanément l'étude des données et l'étude des traitements à effectuer. C'est en général dans cette phase que s'appliquent les techniques de modélisation. Il en découle la description des bases de données éventuelles à créer et les programmes à écrire et la manière dont tout cela va être intégré.
- Spécification
- Conception
- Définition de l'architecture
- Phase de réalisation ou de programmation (écriture et tests des programmes)
- Algorithmique
- Codage
- Programmation
- Contrôle de version
- Refactoring
- Tests unitaires
- Optimisation du code
- Phase de livraison
- Intégration
- Validation
- Documentation du logiciel
- Packaging
Modélisation
Méthodes de modélisation
Une méthode d'analyse et de conception a pour objectif de permettre de formaliser les étapes préliminaires du développement d'un système afin de rendre ce développement plus fidèle aux besoins du client. Parmi les méthodes les plus connues on peut notamment citer Merise, RAD et SADT
article détaillé: méthodes d'analyse et de conception
Méthodes de développement (Gestion de projet)
- Méthode agile
- Extreme programming (XP)
- Dynamic software development method (DSDM)
- Adaptive software development (ASD)
- Scrum
- Feature driven development
- Crystal clear
- Merise
Langages de modélisation
- UML
- BON
Approche objet
- Orienté objet
- Interface de classe
Les écueils classiques
- la balle en argent
- prototypage
- le plaqué or
- la loi de Brooks
Very High Speed Integrated Circuit Hardware Description LanguageCatégorie:Sigle Catégorie:Langage informatique
VHDL (abréviation de VHSIC HDL) est l'acronyme de Very High Speed Integrated Circuit Hardware Description Language.
Il s'agit d'un langage de description du matériel, destiné à décrire le comportement et/ou l'architecture d’un « module » de logique matérielle, c'est-à-dire une fonction combinatoire et/ou séquentielle.
Il est utilisé en conception assisté par ordinateur (CAO) de circuits intégrés, dans le cadre de développement d'ASIC et de FPGA.
Détails techniques
La syntaxe du VHDL est tirée du langage Ada, dont les mots clefs ont été adaptés à la conception matérielle. L'une des particularités du VHDL provient du fait qu'il est possible d'exprimer facilement le parallélisme présent à l'intérieur d'un circuit.
Le but d'un tel langage de description du matériel est de faciliter le développement d'un circuit numérique en fournissant une méthode rigoureuse de description du fonctionnement et de l'architecture du circuit désirée. L'idée est de ne pas avoir à réaliser (fondre) un composant réel, en utilisant à la place des outils de développement permettant de vérifier le fonctionnement attendu. Ce langage permet en effet d'utiliser des simulateurs, dont le rôle est de tester le fonctionnement décrit par le concepteur.
L'étape suivante consiste à synthétiser cette description matérielle pour obtenir un composant réalisant les fonctions désirées, à l'aide d'éléments logiques concrets (portes logiques, bascules ou registres). Ceux-ci seront implémentés, selon la technologie utilisée, soit en transistors (dans le cas d'un ASIC), ou plus couramment en se basant sur les éléments programmables des FPGA. Pour ce dernier cas, il faut alors passer encore par des phases de placement et de routage qui consistent à placer les éléments synthétisés en fonction des ressources particulières disponibles dans les différentes FPGA.
Historique
Originellement commandé par le ministère de la défense américain, celui-ci lui a finalement préféré le langage Verilog HDL, très similaire. Il existe de fait une quasi équivalence entre les deux langages, d'où l'existence de nombreux scripts de traduction de l'un vers l'autre. Le langage VHDL est maintenant principalement utilisé par les entreprises européennes.
La version initiale de VHDL, standard IEEE 1076-1987, incluait un large éventail de types de données, numériques (entiers, réels), logiques (bits, booléens), caractères, temps, plus les tableaux de bits et chaînes de caractères.
L'un des principaux problèmes concernait le type bit. Celui-ci ne pouvant prendre que 2 valeurs (0, 1), il était impossible de représenter les signaux de valeur inconnue ou encore les signaux en haute impédance, ainsi que la "force" d'un signal (faible, forte ou nulle). La norme IEEE 1164 définit le type std_logic avec 9 états possibles. Ceci a été adopté dans le VHDL-93 (seconde version de la norme IEEE 1076).
Afin de répondre aux différents problèmes de l'éléctronique, la norme VHDL a du évolué. L'IEEE Design Automation Standards Committee (DASC) a créé la norme IEEE 1076.1, ou VHDL-AMS (VHDL-Analog & Mixed Systems). Cette nouvelle norme est une extension de la norme IEEE 1076-1987 déjà existante. Elle supporte à présent la description et la simulation de circuits analogiques, numériques, et mixtes (analogique et numérique).
Introduction au VHDL
En VHDL, on décrit l’architecture d’un « module matériel » en deux temps :
- Une ENTITY : il s’agit de déclarer ce que le module expose au monde extérieur, principalement la liste des E/S d’un module (exemple pour une porte logique classique : deux entrées a et b, et une sortie s).
- Une ARCHITECTURE : il s’agit de décrire le fonctionnement d’un module dont les E/S ont été définies dans l'ENTITY. Plusieurs modules aux fonctionnements très différents et donc décrits par plusieurs ARCHITECTUREs, peuvent être basés sur une même ENTITY. (exemple de plusieurs portes logiques à deux entrées et une sortie : ET, OU, XOR…)
C’est donc l'ARCHITECTURE qui contient la description de la fonction matérielle désirée :
- soit sous forme de comportement attendu (behaviour), c'est-à-dire orienté fonctionnel,
- soit sous forme de description précise de l’architecture matérielle (les portes logiques à utiliser).
Dans cette ARCHITECTURE, la logique utilisée peut être :
- soit combinatoire (on dit « concurrente », c'est-à-dire traitements en parallèle),
- soit dépendante du temps (on parle de logique « séquentielle par opposition à la logique concurrente », c'est-à-dire traitements en série).
Exemples de code VHDL
Un multiplexeur 3 vers 1 (trois architectures concurrentes différentes)
En VHDL, il faut distinguer le contenant du contenu, nommés respectivement entité et architecture.
Le fichier VHDL
Un fichier VHDL doit toujours porter le nom de l'entité qu'il contient. Son extension standard est ".vhd"
Avant toute chose, il faut commencer par déclarer l'utilisation des librairies à utiliser dans le projet :
-- En VHDL : une ligne de commentaires commence avec deux "-"
-- le fichier doit porter le même nom que l'entité qu'il décrit, ici ce sera "logique_3_vers_1.vhd"
-- Il faut toujours commencer par importer les bibliothèques VHDL standards normalisées par l'IEEE
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
L'entité
Nous décrivons en premier lieu l'interface (l'entité) d'un composant multiplexeur, entité qui nous serviras pour les trois exemples d'architectures concurrentes permettant de réaliser un multiplexeur.
-- Voici un exemple d’entité, décrivant les E/S utilisées
-- par les trois exemples d’architectures purement concurrentes :
--
-- ATTENTION, l'entité doit avoir le même nom que le fichier (logique_3_vers_1.vhd)
ENTITY logique_3_vers_1 IS
PORT
(
a : IN STD_LOGIC;
b : IN STD_LOGIC;
c : IN STD_LOGIC;
adr : IN STD_LOGIC_VECTOR (1 downto 0);
s : OUT STD_LOGIC
);
END logique_3_vers_1;
Première Architecture
La première architecture permettant de décrire ce multiplexeur est en fait plus particulièrement adaptée aux équations simples, ou aux fonctions en somme de produits impliqants un nombre d'entrées variable (par exemples=a.b+a.b.c) car cette méthode est très souple et permet de tout faire. En contrepartie elle est peu lisible pour les équations complexes.
-- Première architecture concurrente décrivant un mux :
ARCHITECTURE mux_3_vers_1 OF logique_3_vers_1 IS
BEGIN
s <= ( a AND NOT adr(1) AND NOT adr(0) )
OR ( b AND NOT adr(1) AND adr(0) )
OR ( c AND adr(1) AND NOT adr(0) );
-- OR ('0'AND adr(1) AND adr(0) ); -- Cette dernière ligne est implicite dans l'équation du dessus
END mux_3_vers_1;
Deuxième Architecture
La deuxième architecture permettant de décrire ce multiplexeur est limitée aux fonctions dont le nombre d'entrées est fixée (n) pour lesquelles elle est tout particulièrement adaptée. Cependant, avec cette méthode il est obligatoire de lister l'ensemble des états possible (2^n).
-- Deuxième architecture concurrente décrivant un mux :
ARCHITECTURE mux_3_vers_1 OF porte_3_vers_1 IS
BEGIN
WITH adr SELECT
s <= a WHEN "00",
b WHEN "01",
c WHEN "10",
‘0’ WHEN "11";
END mux_3_vers_1;
Troisième Architecture
La troisième architecture permettant de décrire ce multiplexeur est elle aussi limitée aux fonctions dont le nombre d'entrées est fixée (n) pour lesquelles elle est tout particulièrement adaptée. Cependant, avec cette méthode il n'est pas obligatoire de lister l'ensemble des états possible, puisque la dernière ligne permet d'appliquer un traitement par défaut.
-- Troisième architecture concurrente décrivant un mux:
ARCHITECTURE mux_3_vers_1 OF porte_3_vers_1 IS
BEGIN
s <= a WHEN adr = "00" ELSE
b WHEN adr = "01" ELSE
c WHEN adr = "10" ELSE
‘0’;
END mux_3_vers_1;
Architecture séquentielle - une bascule D
La description d'une architecture séquentielle, c'est à dire avec d'une fonction dépendante du temps (ie. de l'horloge) passe par l'utilisation de process.
-- Architecture séquentielle pour une bascule D :
ARCHITECTURE bascule_d OF xxx IS
BEGIN
bascule : PROCESS (clk, reset)
IF reset = ‘1’ THEN
q <= 0;
ELSE
IF clk’event AND clk = ‘1’ THEN
q <= d;
END IF;
END IF;
END bascule;
END bascule_d;
Hello World
-- En VHDL, une ligne de commentaires commence par deux "-"
-- Programme d'exemple VHDL: hello.vhd
-- La directive "use" permet d'inclure des packages externes
use std.textio.all;
-- le concept d'entity (entite) est ce qui sera exposé
-- au monde extérieur. Ici ne sont décrites que les entrées/sorties
ENTITY hello IS
-- aucune description ici
END ENTITY hello;
-- on peut implémenter une entity de multiples manières, en utilisant
-- les architectures. C'est pourquoi il convient de nommer chaque
-- implémentation.
ARCHITECTURE Wiki OF hello IS
CONSTANT message : string := "hello world";
-- bien que le VHDL le permette, une telle chaîne de caractères n'a aucun sens
-- en implémentation matérielle.
BEGIN
-- un process peut être considéré comme une description séquentielle d'un
-- comportement.
PROCESS
variable L: line;
BEGIN
write(L, message);
writeline(output, L);
wait;
END PROCESS;
END ARCHITECTURE Wiki;
ja:VHDL
Codage
Cet article concerne le codage de données en général. Pour ce qui est de l'acte de programmer, se référer à codage (programmation).
De façon générale un codage permet de passer d'une représentation des données vers une autre.
Parmi les différents codages utilisés, on trouve :
- Le codage de Huffman, qui permet de faire de la compression de données (essentiellement sur du texte).
- Le codage de caractères pour représenter les textes dans diverses langues.
- La transformation d'une source vidéo ou sonore en un format informatique déterminé. Coder en MP3, en AVI, etc. Dans ce cas, le codage n'est plus une opération mathématique bijective (réversible) et l'expression encodage numérique est préférée.
Le codage fait appel à des codec (CODeur/DECodeur) s'appuyant sur des algorithmes afin de compresser une source pleine en une forme plus légère, mais toujours exploitable lors du décodage, par ces mêmes codecs.
Contrôle de versionLa 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:バージョン管理システム
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 (102) décalé de 1 bit donne 4 (1002).
:5 (1012) décalé de 2 bits donne 20 (101002) : .
Ceci marche aussi pour la division, en décalant les bits vers la droite.
:100 (11001002) décalé de 3 bits vers la droite donne donc 12 (11002) 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
RefactoringCaté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:リファクタリング (プログラミング)
Programmation impérative
En informatique, la programmation impérative est un style de programmation qui décrit les opérations en termes d'états du programme et de séquences d'instructions exécutées par l'ordinateur pour modifier l'état du programme.
L'implémentation de la quasi totalité des microprocesseurs qui équipent les ordinateurs est de nature impérative : ils sont faits pour exécuter du code écrit sous forme d'opcodes (pour operation codes), qui sont des instructions élémentaires exécutables par le microprocesseur. L'ensemble des opcodes forme le langage machine spécifique au microprocesseur et à son architecture. L'état du programme à un instant donné est défini par le contenu de la mémoire centrale à cet instant, et le programme lui-même est écrit en style impératif en langage machine, ou le plus souvent dans une traduction lisible par les humains du langage machine, dénommée assembleur. Les langages de plus haut niveau utilisent des variables et des opérations plus complexes, mais suivent le même paradigme. Les recettes de cuisine et les vérifications de process industriel sont deux exemples de concepts familiers qui s'apparentent à de la programmation impérative; de ce point de vue, chaque étape est une instruction, et le monde physique constitue l'état modifiable. Puisque les idées basiques de la programmation impérative sont à la fois conceptuellement familières et directement intégrées dans l'architecture des microprocesseurs, la grande majorité des langages de programmation sont impératifs.
La plupart des langages de haut niveau comportent quatre types d'instructions principaux : l'assignation, le bouclage, le branchement conditionnel, et le branchement sans condition.
- Les instructions d'assignation, en général, effectuent une opération sur l'information en mémoire et y enregistrent le résultat pour un usage ultérieur. Les langages de haut niveau permettent de plus l'évaluation d'expressions complexes, qui peuvent consister en une combinaison d'opérations arithmétiques et d'évaluations de fonctions, et l'assignation du résultat en mémoire.
- Les branchements conditionnels permettent à un bloc d'instructions de n'être exécuté que si une condition prédéterminée est réalisée. Dans le cas contraire, les instructions sont ignorées et la séquence d'exécution continue à partir de l'instruction qui suit immédiatement la fin du bloc.
- Les branchements sans conditions permettent à la séquence d'exécution d'être transférée à un autre endroit du programme. Cela inclut le saut, appelé « goto » dans de nombreux langages, et les sous-programmes, ou appels de procédures.
- Les instructions de bouclage servent à répéter une suite d'instruction un nombre prédéfini de fois, ou jusqu'à ce qu'une certaine condition soit réalisée. Les instructions de bouclage peuvent être vues comme des sauts conditionnels, c'est-à-dire la combinaison d'un branchement conditionnel et d'un saut.
Un bref historique
Les langages impératifs les plus anciens sont les langages machine des premiers ordinateurs. Dans ces langages, le jeu d'instructions était minimal, ce qui rendait l'implémentation hardware plus simple, mais empêchait la création de programmes complexes. Le premier compilateur - un programme destiné à vérifier un programme au préalable et à le traduire en langage machine - dénommé A0, fut écrit en 1951 par Grace Murray Hopper. FORTRAN, développé par John Backus chez IBM à partir de 1954, fut le premier langage de programmation capable de réduire les obstacles présentées par le langage machine dans la création de programmes complexes. FORTRAN était un langage compilé, qui autorisait entre autre l'utilisation de variables nommées, d'expressions complexes, et de sous-programmes. Après plusieurs révisions du langage, en 1978 et en 1990, FORTRAN est toujours utilisé dans le milieu scientifique pour la qualité de ses bibliothèques numériques et sa grande rapidité, ce qui en fait le langage informatique ayant eu la plus grande longévité. Les deux décennies suivantes virent l'apparition de plusieurs autres langages de haut niveau importants. ALGOL, développé en 1958 par un consortium américano-européen pour concurrencer FORTRAN, qui était un langage propriétaire, fut l'ancêtre de nombreux langages de programmation d'aujourd'hui. COBOL (1960) et BASIC (1964) étaient deux tentatives pour rendre la syntaxe plus proches de l'anglais, et donc plus accessible. COBOL était spécifiquement destiné aux applications de gestion, tandis que BASIC avait essentiellement un but éducatif. Sa simplicité et le fait qu'il soit interprété facilitait grandement la mise au point des programmes, ce qui lui conféra rapidement une grande popularité, malgré la pauvreté de ses constructions. Malheureusement, cette pauvreté même devait mener à une quantité de programmes non structurés et donc difficilement maintenables. Après un article de Dijkstra dénonçant les ravages de BASIC, la réputation de BASIC comme langage pour l'enseignement de la programmation déclina.
Dans les années 1970, le Pascal fut développé par Niklaus Wirth, dans le but d'enseigner la programmation structurée et modulaire. Pascal combinait les meilleures constructions des langages COBOL, FORTRAN et ALGOL dans un ensemble élégant, mais simpliste, qui lui assura un succès durable comme langage d'initiation (en remplacement de BASIC). À la même époque, Dennis Ritchie créa C aux laboratoires Bell, pour le développement du système Unix. La puissance du C, permettant grâce aux pointeurs de travailler à un niveau proche de la machine, ainsi qu'un accès complet aux primitives du système lui assura un succès qui ne s'est jamais démenti depuis. Par la suite, Niklaus Wirth fut à l'origine de Modula-2, Modula-3, et d'Oberon, les successeurs de Pascal. En 1974, le Department of Defense des États-Unis cherchait un langage dont le cahier des charges mettait l'accent sur la sûreté d'exécution, pour tous ses besoins futurs. Le choix se porta sur Ada, langage créé par Jean Ichbiah à Honeywell, dont la spécification ne fut complétée qu'en 1983.
Dans les années 1980, devant les problèmes que posait la complexité grandissante des programmes, il y eut un rapide gain d'intérêt pour la programmation orientée objet. Smalltalk-80, conçu à l'origine par Alan Kay en 1969, fut présenté en 1980 par le Palo Alto Research Center de la compagnie Xerox (États-Unis). À partir des concepts objet, Bjarne Stroustrup, chercheur aux Bell Labs, conçut en 1985 une extension orientée objet de C nommée C++, qui gardait la vitesse de C. Parallèlement, une extension à C moins ambitieuse, mais inspirée de Smalltalk avait vu le jour, Objective C. Le succès d'Objective C, notamment utilisé pour le développement sur les stations NeXT et Mac OS X, est resté faible par rapport à C++. Le langage Common Lisp fut le premier langage à objets (CLOS) standardisé par l'ANSI, en 1995. Dans les décennies 1980 et 1990, de nouveaux langages impératifs interprétés ou semi-interprétés doivent leur succès au développement de scripts pour des pages web dynamiques et les applications client-serveur. On peut citer dans ces catégories Perl (Larry Wall, 1987), Python (Guido van Rossum, 1990), PHP et Java (Sun Microsystems, 1996).
Les langages de programmation impératifs doivent être distingués d'autres types de langages, les langages fonctionnels et les langages de programmation logique. Les langages fonctionnels, tels que Haskell ou ML, ne sont pas des suites d'instructions et ne s'appuient pas sur l'idée d'état global, mais au contraire tendent à s'extraire de ce modèle pour se placer à un niveau plus conceptuel (qui a ses fondations dans le lambda-calcul). Les langages de programmation logiques, tels que Prolog, se concentrent sur ce qui doit être calculé, et non comment le calcul doit être effectué.
Liens externes
Un [http://www.levenez.com/lang/ synoptique] de l'histoire des langages de programmation. Un autre se trouve [http://merd.net/pixel/language-study/diagram.html ici].
Catégorie:Programmation informatique
Programmation orientée objet ms:Pengaturcaraan Berorientasikan Objek ja:オブジェクト指向 th:การเขียนโปรแกรมเชิงวัตถุ
La programmation orientée objet (POO, également appelée programmation à objets), est une façon d'architecturer une application informatique en regroupant les données et les traitements sur ces dernières au sein d'une même entité, les objets.
Origines
La programmation orientée objet (venant de l’anglais Object-Oriented Programming) est née des travaux sur la mise au point de langages de simulation dans les années 1960 (par exemple Simula-67), et a été utilisée également dans le cadre de recherches sur l’intelligence artificielle dans les années 1970-80.
Pourquoi regrouper les données et les traitements? Pour permettre plus facilement des modifications fondamentales dans la façon de représenter et de traiter les données.
Imaginons par exemple que nous souhaitions traiter des nombres complexes. Vaut-il mieux les représenter de façon cartésienne (x, y) ou polaire (angle, module)? Nous ne le saurons qu’en effectuant des statistiques dans l’application où nous les utiliserons, et nous ne pourrons effectuer ces statistiques qu’en créant justement un premier modèle opérationnel : il semble que nous soyons pris dans une autoréférence fâcheuse.
Si nous convenons que nous disposons d’une boîte noire que nous nommerons un objet « nombre complexe » et qu’il soit possible de lui affecter des valeurs en représentation polaire ou cartésienne, comme d’aller les lire en polaire ou en cartésien selon ce qui nous arrange le mieux, nous pouvons différer ce choix, et le changer à tout moment rien qu’en modifiant la définition de ce seul objet. Par comparais |