Modula-II

Modula
Apparu en	1977
Auteur	Niklaus Wirth
Paradigme	générique, procédural, impératif
Typage	statique, safe, nominatif
Dialectes	Modula, Modula-1, Modula-2, ISO-Modula, Modula-3
Influencé par	ALGOL, Pascal
A influencé	Java, Oberon
Implémentations	Windows, OS/2,Solaris, Macintosh, Unix

Modula est un langage de programmation créé en 1977 par Niklaus Wirth à l'École polytechnique fédérale de Zurich. Sa syntaxe est une amélioration de celle du langage Pascal dont il reprend bon nombre de principes.

Modula est un langage de programmation compilé, procédural, fortement typé, modulaire, facile à lire (il se lit de gauche à droite) et à apprendre. Il est conçu pour enseigner la programmation et faciliter le développement des projets de grande ampleur. Il supporte notamment les concepts d'encapsulation en modules - d'où le nom du langage, la notion d'interface, de bibliothèque, de primitive, d'unité de compilation, la programmation de haut et de bas niveau, la programmation concurrente et la portabilité.

primitive : fonction qui effectue une tâche élémentaire telle que ouverture de fichier ou affichage à l'écran.

unité de compilation: Dans un programme de grande dimension, un seul fichier exécutable peut contenir plusieurs fonctionnalités, le code source de chaque fonctionnalité peut être réparti sur plusieurs fichiers sources. Les fichiers sont alors compilés par petit groupes appelés unité de compilation.

Sommaire 1 Dialectes et langages apparentés 2 Compilateurs Modula 3 Caractéristiques du langage Modula 3.1 Typage fort et données brutes 3.2 Modules, interfaces, encapsulation et unité de compilation 3.3 Primitives et bibliothèques 3.4 Programmation concurrente 3.5 Programmation de haut niveau et portabilité 4 Lilith 5 Voir aussi 5.1 Références 5.2 Liens externes

Dialectes et langages apparentés

Algol W et Pascal (Niklaus Wirth, 1970) sont les ancêtres de Modula.

Oberon est un descendant direct de Modula. (Niklaus Wirth, 1985)

Modula a influencé les langages Java et C#

dialectes

• Modula, aussi appelé Modula-1. Niklaus Wirth, 1977
• Modula-2. Niklaus Wirth, 1978
• ISO-Modula. International Organisation for Standardisation, 1987.
• Modula-3. 1980

Compilateurs Modula

• XDS: compilateur Modula-2 et Oberon pour x86 (Windows, OS/2, Linux)
• Stony Brook: compilateur ISO-Modula et Pascal pour x86 (DOS, Windows, Linux) et SUN Solaris
• MacMETH: pour Macintosh
• MOCKA : pour de nombreux Unix - Sun Solaris, SGI Irix, Hewlett Packard HPUX, Linux, BSD

Caractéristiques du langage Modula

La syntaxe générale de Modula est celle de Pascal. La différence majeure étant l'usage moins fréquent du mot clé BEGIN, et le remplacement du mot clé PROGRAM par MODULE, IMPLEMENTATION MODULE ou DEFINITION MODULE selon les cas.

Comme dans le langage Pascal, les mots réservés et noms des éléments de base (fonctions, types et constantes) sont écrits en majuscule.

exemple: Hello World écrit en Modula :

   MODULE Hello;
 
   FROM Terminal IMPORT WriteLn, WriteString;
 
   BEGIN
      WriteString("Hello world!");
      WriteLn;
   END Hello.

Typage fort et données brutes

Modula est un langage fortement typé, qui interdit toute conversion entre deux types où il y a possibilité de perte d'information tout en permettant la manipulation de données brutes et non typées.

Les types de base sont INTEGER (nombre entier), REAL (nombre à virgule flottante), CHAR (caractère), et BOOLEAN. (booléen)

Modula offre de nombreuses possibilités de créer des types complexes tels que tableaux ARRAY, enregistrements RECORD, pointeurs typés POINTER, énumérations, intervalles, groupe de flags SET OF.

Modula offre la possibilité de créer des callback par l'utilisation de types PROCEDURE.

Modula offre aussi la possibilité de manipuler des informations brutes et non typées, grâce au types génériques BYTE et WORD (octet), ADDRESS (pointeur non typé + nombre) et BITSET (groupe de flags non typé)

si un paramètre d'une fonction est de type ARRAY OF BYTE (tableau d'octets de taille quelconque), le paramètre pourra contenir en vrac n'importe quel type d'information.

Modules, interfaces, encapsulation et unité de compilation

en Modula le mot clé MODULE sert à encapsuler des éléments tels que des variables, des types ou des fonctions, c'est-à-dire à les rendre invisibles de l'extérieur du module, afin de cacher les détails internes de la construction du module.

un module peut contenir d'autres modules..

La compilation peut se faire en plusieurs étapes. une unité de compilation à la fois.

Pour un programme ordinaire l'unité de compilation est composée d'un seul fichier source qui commence par MODULE. Pour une bibliothèque l'unité de compilation est composée de deux fichiers source, un qui commence par DEFINITION MODULE et un qui commence par IMPLEMENTATION MODULE.

Dans le DEFINITION MODULE sont déclarés les éléments qui seront rendu publics et dont utilisables par les programmes qui exploiteront ce module. et dans le IMPLEMENTATION MODULE se trouve les éléments privés, ainsi que les instructions.

Pour pouvoir utiliser dans un module B un élément (fonction, type, variable) provenant d'un module A, il est nécessaire d'ajouter au début du module B le mot clé FROM suivi du nom du module, puis du mot IMPORT et de la liste des éléments.

Primitives et bibliothèques

Le langage Modula comporte seulement quelques instructions : INC, DEC, INCL, EXCL, CHR et ORD.

Dans les programmes écris en Modula, la majorité des opérations se font par l'utilisation des primitives incluses dans un ensemble de bibliothèques fournies avec le compilateur. les fonctions dans ces bibliothèques peuvent varier selon le système et le compilateur.

Le langage offre la possibilité de créer des bibliothèques, et toutes les bibliothèques de primitives fournies avec le compilateur sont écrites en Modula, exception faite des bibliothèques SYSTEM et COROUTINES.

Chaque bibliothèque consiste en un fichier de définition DEFINITION MODULE et un fichier d'implémentation IMPLEMENTATION MODULE.

Dans le fichier de définition sont déclarés les éléments qui seront rendu publics et dont utilisables par les programmes qui exploiteront ce module. et dans le fichier d'implémentation se trouve les éléments privés, ainsi que les instructions.

Programmation concurrente

La programmation concurrente en Modula est basée sur les coroutines et les variables de contexte. le contexte étant l'instruction qu'une coroutine était en train d'exécuter à un moment donné (voir commutation de contexte).

Le type de données contexte s'appelle PROCESS en Modula-1 et Modula-2 et COROUTINE en Modula-3.

L'instruction TRANSFER permet d'arrêter l'exécution de la coroutine en cours A, et de relancer l'exécution d'une coroutine quelconque B. le contexte d'exécution de la coroutine B est passé en paramètre. La coroutine A sera suspendue - l'exécution de l'instruction TRANSFER est ne se terminera pas - jusqu'à ce qu'une autre coroutine utilise l'instruction TRANSFER.

L'instruction IOTRANSFER permet d'arrêter l'exécution de la coroutine en cours A et de relancer l'exécution d'une coroutine quelconque B jusqu'à ce qu'une interruption matérielle survient. La coroutine A reste suspendue jusqu'à la venue de l'interruption.

Une instruction permet de créer un nouveau contexte pour une coroutine.

Ces trois instruction suffisent à réaliser un noyau multitâche préemptif, des thread légers, ainsi que des mécanismes de synchronisation. Des mécanismes qui sont souvent inclus dans les bibliothèques fournies avec le compilateur Modula.

Programmation de haut niveau et portabilité

Modula est un langage de programmation de haut niveau, c'est-à-dire qu'il permet d'écrire un programme sous une forme proche de la pensée humaine, et cache les détails techniques de la machine sur laquelle le programme va être exécuté.

Un langage de programmation de haut niveau permet d'écrire des programmes portables. C'est-à-dire qu'un programme écrit pour un système peut, moyennant quelques changements mineurs, être recompilé sur un autre système.

Pour faciliter les modifications, les éléments du langage qui peuvent différer d'un système à l'autre sont encapsulés dans les modules SYSTEM et COROUTINE. Il y a notamment les types de données de bas niveau BYTE, ADDRESS, BITSET, PROCESS et COROUTINE. ainsi un module qui risque de demander des changements peut être repéré facilement par le fait qu'il importe des éléments du module SYSTEM ou COROUTINE.

La majorité des instructions dans un programme écrit en Modula consistent à utiliser des fonctions incluses dans les librairies fournies avec le compilateur. Tout comme dans le langage C, il existe une suite de librairies standard et communes à tous les compilateurs. suite à laquelle se rajoutent diverses librairies, différentes d'un compilateur à l'autre.

Lilith

Lilith est le nom d'une station de travail conçue en 1978 par L'école Polytechnique Fédérale de Zürich, et dont le logiciel est entièrement écrit en Modula.

Le logiciel inclut un compilateur, un système d'exploitation, un environnement graphique et divers outils. Le développement de la machine était à la fois un exercice grandeur nature pour les élèves des facultés d'électronique et d'informatique de l'université, et une occasion d'évaluer les qualités et les défauts de Modula sur les projets de grande ampleur.

Voir aussi

Références

(en) Niklaus Wirth, Programming in Modula-2, Springer-Verlag, Berlin, 1982 (ISBN 3-540-11674-5) 

Liens externes

• (en) http://www.ethistory.ethz.ch/rueckblicke/departemente/dinfk/weitere_seiten/lilith/index_EN
• (en) http://www.arjay.bc.ca/Modula-2/m2faq.html Modula-2 FAQ

• Portail de l’informatique