Cet article ne cite pas suffisamment ses sources ().
Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».
En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?
| Simula | ||
 | ||
| Date de première version | 1967 | |
|---|---|---|
| Paradigmes | Objet | |
| Auteur | Ole-Johan Dahl, Kristen Nygaard | |
| Dernière version | Standard SIMULA ()[1] | |
| Influencé par | Algol 60 | |
| A influencé | Les langages orientés objet | |
| modifier |
||
Simula (Simple universal language) a été créé en 1962 sous la dénomination Simula I par Ole-Johan Dahl et Kristen Nygaard à partir d'Algol 60. Le langage évolua en 1967 sous le nom de Simula 67 en implémentant le premier le modèle de classe de Hoare (Record Class, Hoare 1965). Il est donc le premier langage à classes et donc le père de tous les langages à classes tels que Smalltalk, C++, Java, ou encore Eiffel. Il inspira Dan Ingalls dans la conception de Smalltalk qui introduisit la programmation orientée objet.
Historique
[modifier | modifier le code]Simula a été développé dans les années 1960 au Norwegian Computing Centre d'Oslo, initialement par Ole-Johan Dahl et Kristen Nygaard. Syntaxiquement parlant, c'est un sur-ensemble d'Algol, qui ajoute à celui-ci les concepts, aujourd'hui familiers, des langages à classes comme C++ ou Java, et de la simulation à événements discrets.
Simula a été utilisé pour des applications industrielles jusqu'à aujourd'hui[Quand ?], mais son influence historique est considérée comme plus importante que les applications qui auraient pu être développées avec lui.
Par Simula on entend généralement Simula 67, c'est-à-dire la version de 1967, alors que la version précédente datait de 1962 : Simula I.
Simulation discrète
[modifier | modifier le code]Comme son nom l'indique, en plus de constituer un langage de programmation généraliste, Simula a été conçu de façon à contenir des bibliothèques de classes offrant un support de concepts spécifiques à la simulation à événements discrets. La classe Process, héritant de Simulation permettait ainsi à l'utilisateur d'hériter pour ses propres classes de simulation du comportement de base d'un processus pouvant s'exécuter en mode dit « quasi-parallèle », à l'aide du concept de coroutine.
Une coroutine est une routine à plusieurs points de sortie et qui, à chaque ré-entrée du flot d'exécution dans celle-ci lors d'un appel à l'instruction Resume, reprend son exécution à la dernière instruction où le flot l'avait précédemment quittée lors d'un appel à l'instruction Detach. Le point d'exécution est stocké dans le LSC : Local Sequence Counter.
Pour clarifier le propos, le programme suivant produirait l'affichage indiqué plus bas :
Begin Ref(TwinProcess) firstProc, secondProc; Class TwinProcess(Name); Text Name; Begin ! Initial coroutine entry (creation) Ref(TwinProcess) Twin; OutText(Name); OutText(": Creation"); OutImage; ! First coroutine exit Detach; ! Second coroutine entry OutText(Name); OutText(": Second coroutine entry"); OutImage; ! Second coroutine exit: switch to the twin's coroutine Resume(Twin); ! Last coroutine entry OutText(Name); OutText(": Last coroutine entry"); OutImage; Resume(Twin); End; Begin firstProc :- New TwinProcess ("1st Proc"); secondProc :- New TwinProcess ("2nd Proc"); firstProc.Twin :- secondProc; secondProc.Twin :- firstProc; OutText("Starting"); OutImage; Resume(firstProc); OutText("End"); End; End;
Affichage :
1st Proc: Creation 2nd Proc: Creation Starting 1st Proc: Second coroutine entry 2nd Proc: Second coroutine entry 1st Proc: Last coroutine entry 2nd Proc: Last coroutine entry End
La bibliothèque de simulation discrète permettait de gérer la file des processus au moyen d'instructions dédiées (Activate, Passivate, Hold, etc.)
Programmation objet
[modifier | modifier le code]La plupart des constructions qui permettront plus tard la réalisation des concepts principaux de la programmation orientée objet sont d'ores et déjà présents dans Simula 67 :
- les classes comme structure de données dans Simula rassemblant variables et opérations sur ces dernières (dans Simula, il représentaient des activités),
- l'instanciation via l'instruction New,
- les relations entre objets (ou processus dans le jargon originel de Simula) au moyen de références : Ref( ) et affectation de références avec l'instruction :-
- référence sur l'instance courante grâce au mot clé This
- Test de référence nulle automatique nativement supporté Inspect-Do-Otherwise : Inspect rect do Draw. Ici, x.Draw ne sera appelé que si x n'est pas une référence nulle (mot clé : None)
- fonctions virtuelles
- appel de méthode par notation pointée (dot-notation) : <objet>.<méthode>
- appel qualifié (i.e. statiquement lié) de méthodes virtuelles à l'aide de l'opérateur Qua ou avec Inspect-When
- reconnaissance de type à l'exécution (instruction Inspect, Is, In)
- héritage simple entre classes
- restriction d'accès (Hidden, Protected)
- classes imbriquées (ou internes)
- Imbrication sophistiquée des appels du corps de méthode de la classe via l'instruction Inner, qui peut ainsi permettre d'obliger l'exécution de code avant et/ou après l'exécution du corps d'une classe dérivée : on voit déjà se profiler le concept d'assertions, implémentées par Eiffel dans les années 1980, ou même la programmation par aspect, qui sera développée dans les années 1990.
- un ramasse-miettes en anglais : garbage-collector.
Cette liste succincte permet de prendre conscience de la percée conceptuelle opérée par Simula en 1967 dans le domaine des langages impératifs structurés.
Les auteurs de Simula apportèrent une certaine confusion dans le monde de la programmation orientée objet. À l'apparition de ce nouveau paradigme avec Smalltalk, Ole Johan Dahl et Kristen Nygaard changèrent les dénominations utilisées dans Simula pour se conformer aux concepts véhiculés dans Smalltalk (classes d'objets, objets, attributs, méthodes, etc.) et déclarèrent que Simula 67 était en fait le premier langage orienté objet. Pourtant, l'approche utilisée dans Simula 67 n'est pas celle définie par Alan Kay, l'auteur de la programmation orientée objet.
Notes et références
[modifier | modifier le code]Voir aussi
[modifier | modifier le code]Articles connexes
[modifier | modifier le code]- Programmation orientée objet
- BETA (le successeur de Simula)
Liens externes
[modifier | modifier le code]
- Notices dans des dictionnaires ou encyclopédies généralistes :
- (en) Introduction to OOP in Simula – par J.Sklenar, basé sur le séminaire de 1997 « 30 Years of Object Oriented Programming (OOP) » de l'Université de Malte
- (en) How Object-Oriented Programming Started – par Dahl et Nygaard, version abrégée d'un article d'une encyclopédie sur la page du site de Nygaards.
