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:Симула]]