Simula
263155
31823810
2008-07-23T16:16:43Z
Haypo
2366
/* Programmation objet */
'''Simula''' ('''Sim'''ple '''u'''niversal '''la'''nguage) est le langage qui a introduit le paradigme [[orienté objet]] en [[programmation]], en 1960, et il est donc considéré comme le premier [[Programmation orientée objet|langage à objet]] et le prédécesseur de langages ultérieurs tels que [[Smalltalk]], [[C plus plus|C++]] et surtout [[Eiffel (langage)|Eiffel]]. Simula est basé sur [[Algol (langage)|Algol 60]].
== Historique ==
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 (langage)|Algol]], qui ajoute à celui-ci les concepts, aujourd'hui familiers, de la programmation objet et de la simulation discrète.
Simula n'a jamais été un simple langage universitaire, puisqu'il a été utilisé pour des applications industrielles {{Quand|jusqu'à aujourd'hui}}, 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 1964 : '''Simula I'''.
== Simulation discrète ==
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 discrète'''. 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é 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 ==
Tous les grands concepts (et même plus) de ce qui sera appelé plus tard la [[programmation orientée objet]] sont d'ores et déjà présents dans '''Simula''', qui les inaugure (polymorphisme, encapsulation, etc.) et qui alliait de surcroit la clarté syntaxique de l'Algol :
* les '''classes''', les '''attributs''' et les '''méthodes'''
* l'instanciation via l'instruction '''New'''
* les '''relations''' entre objets au moyen de références d'objet : '''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''')
* fonction 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 (langage)|Eiffel]] dans les années 80, ou même la [[Programmation orientée aspect|programmation par aspect]], qui sera développée dans les années 1990.
* un [[ramasse-miettes]] (garbage-collector).
Cette liste succincte permet de prendre conscience de la '''percée conceptuelle''' opérée par Simula dans les années 1960.
== Voir aussi ==
*[[Programmation orientée objet]]
*[[BETA]] (le successeur de Simula)
== Liens externes ==
* [http://staff.um.edu.mt/jskl1/talk.html 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
* [http://heim.ifi.uio.no/~kristen/FORSKNINGSDOK_MAPPE/F_OO_start.html 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.
{{Portail|programmation informatique}}
[[Catégorie:Langage de programmation]]
[[Catégorie:Langage orienté objet]]
[[ca:Simula67]]
[[cs:Simula 67]]
[[de:Simula]]
[[en:Simula]]
[[es:Simula]]
[[fa:سیمولا]]
[[hu:Simula]]
[[it:Simula]]
[[ja:Simula]]
[[ko:시뮬라]]
[[nl:Simula]]
[[no:Simula]]
[[pl:Simula]]
[[pt:Simula]]
[[ru:Симула]]
[[sk:Simula]]
[[sv:Simula]]
[[tg:Simula]]
[[th:ภาษาซิมูลา]]
[[uk:Симула]]