From fr.wikipedia.org:
[date=mai 2025] {{Infobox Langage de programmation | couleur boîte = b22222 |
nom = [Simula] | logo = | paradigmes = Objet | date de première version = 1967
| auteur = Ole-Johan Dahl, Kristen Nygaard | développeurs = | dernière version
= | typage = | implémentations = | dialectes = | influencé par = Algol 60 | a
influencé = Les langages orientés objet | système d'exploitation = | licence =
| site web = }} SIMULA ([en]) 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
Simula a été développé dans les années 1960 au [en] 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], 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
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 [en], 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 : [en].
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
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 [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
[Références]
** Voir aussi
*** Articles connexes
- Programmation orientée objet
- BETA (le successeur de Simula)
*** Liens externes
[Liens]
- [en] [en] (see http://staff.um.edu.mt/jskl1/talk.html) – par J.Sklenar, basé sur le séminaire de 1997 « [en] (OOP) » de l'Université de Malte
- [en] [en] (see http://heim.ifi.uio.no/~kristen/FORSKNINGSDOK_MAPPE/F_OO_start.html) – par Dahl et Nygaard, version abrégée d'un article d'une encyclopédie sur la page du site de Nygaards.
[Langages de programmation] [programmation informatique]
Catégorie:Langage de programmation Catégorie:Langage orienté objet