Cours NetRexx

Cours Complet de NetRexx en PDF


Télécharger Cours Complet de NetRexx en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Cours Complet de NetRexx en pratique [Eng]

...

Introduction

NetRexx est un langage de programmation généraliste inspiré de deux langages de programmation très différents, Rexx et JavaTM. Il est conçu pour les gens, pas pour les ordinateurs. À cet égard, il suit Rexx de près, avec de nombreux concepts et la plupart de la syntaxe prise directement à partir de Rexx ou de sa version orientée objet, Object Rexx. À partir de Java, il dérive le typage statique, l'arithmétique binaire, le modèle objet et la gestion des exceptions. La langue résultante fournit non seulement les capacités de script et l'arithmétique décimale de Rexx, mais s'étend également de manière transparente au développement d'applications volumineuses avec une arithmétique binaire rapide.

L'implémentation de référence de NetRexx produit des classes pour la machine virtuelle Java et, ce faisant, démontre la valeur de cette interface concrète entre le langage et la machine: les classes NetRexx et les classes Java sont entièrement équivalentes - NetRexx peut utiliser n'importe quel Java class (et vice versa) et hérite de la portabilité et de la robustesse de l'environnement Java.

Ce document est en trois parties:

  1. Les objectifs du langage NetRexx et les concepts sous-jacents à sa conception, et les remerciements.
  2. Une vue d'ensemble et une introduction au langage NetRexx.
  3. La définition de la langue.

Les annexes incluent un exemple de programme NetRexx, une description d'une fonctionnalité expérimentale et quelques détails sur le contenu du paquet netrexx.lang.

Objectifs linguistiques

Ce document décrit un langage de programmation, appelé NetRexx, qui est dérivé à la fois de Rexx et de Java. NetRexx est conçu comme un dialecte de Rexx qui peut être aussi efficace et portable que des langages tels que Java, tout en préservant le faible seuil d'apprentissage et la facilité d'utilisation du langage Rexx original.

Caractéristiques de Rexx

Le langage de programmation Rexx1 a été conçu avec un seul objectif: rendre la programmation plus facile qu'avant. La conception a atteint cet objectif en mettant l'accent sur la lisibilité et la facilité d'utilisation, avec un minimum de notations spéciales et de restrictions. Il a été conçu consciemment pour rendre la vie plus facile pour ses utilisateurs, plutôt que pour ses exécutants.

Une caractéristique importante de la syntaxe Rexx est la sécurité des mots-clés. Les langages de programmation doivent invariablement évoluer au fil du temps à mesure que les besoins et les attentes de leurs utilisateurs changent, c'est donc une exigence essentielle pour les langages destinés à être exécutés à partir de la source.

Les mots-clés dans Rexx ne sont pas globalement réservés mais ne sont reconnus que dans leur contexte. Cet attribut de langue a permis à la langue d'être étendue considérablement au cours des années sans invalider les programmes existants. Même ainsi, certaines zones de Rexx se sont avérées difficiles à étendre - par exemple, les mots-clés sont réservés dans les instructions telles que do. Par conséquent, la conception de NetRexx prend le concept de la sécurité des mots-clés encore plus loin que dans Rexx, et améliore également l'extensibilité dans d'autres domaines.

Les grandes forces de Rexx sont ses caractéristiques axées sur l'humain, y compris

  • Simplicité

Une syntaxe cohérente et épurée

  • Manipulation complète des chaînes
  • · Insensibilité à la casse

Arithmétique décimale de précision arbitraire.



Des précautions ont été prises pour les préserver. Inversement, son caractère interprétatif a toujours entraîné un manque d'efficacité: il existe d'excellents compilateurs Rexx, d'IBM et d'autres entreprises, mais ils ne peuvent pas offrir toute la vitesse des langages statiques tels que C 2 ou Java. 3

Influence de Java

La conception indépendante du système de Rexx en fait un ajustement évident et naturel à un environnement d'exécution indépendant du système, tel que celui fourni par la machine virtuelle Java (JVM). La JVM, en particulier lorsqu'elle est améliorée avec des compilateurs bytecode «just-in-time» qui compilent des bytecodes en code natif juste avant l'exécution, offre un environnement cible efficace et attrayant pour un langage comme Rexx.

Le choix de la JVM en tant qu'environnement cible impose toutefois des contraintes importantes à la conception d'un langage adapté à cet environnement. Par exemple, la sémantique de l'invocation de méthode est déterminée de plusieurs façons par l'environnement plutôt que par le langage source, et, dans une large mesure, le modèle objet (structure de classe, etc.) de l'environnement Java est imposé aux langages utilisant il.

En outre, Java maintient le concept C des types de données primitifs; types (tels que int, un entier signé 32 bits) qui permettent une utilisation efficace du matériel sous-jacent mais ne décrivent pas les objets réels. Ces types sont omniprésents dans les classes et les interfaces écrites en langage Java; tout langage ayant l'intention d'utiliser efficacement les classes Java doit fournir un accès à ces types.

De même, le modèle d'exception (gestion des erreurs) de Java est omniprésent, dans la mesure où les méthodes doivent vérifier certaines exceptions et déclarer celles qui ne sont pas gérées dans la méthode. Cela rend difficile l'ajustement d'un modèle d'exception alternatif.

Les contraintes de sécurité, d'efficacité et d'environnement nécessitaient que NetRexx diffère dans certains détails de la syntaxe et de la sémantique de Rexx; Contrairement à Object Rexx, il ne peut s'agir d'une extension entièrement compatible vers le haut de la langue. Le besoin de changements a toutefois permis de simplifier et d'améliorer considérablement le langage, à la fois pour améliorer la sécurité de ses mots-clés et pour renforcer d'autres caractéristiques du design original de Rexx.5 Certains ajouts d'Object Rexx et d'ANSI Rexx 6 également compris.

De même, les concepts et la philosophie du design Rexx peuvent être appliqués de manière rentable pour éviter de nombreuses irrégularités mineures qui caractérisent la famille des langages C et Java, en fournissant des simplifications appropriées dans le modèle de programmation. Par exemple, la construction en boucle NetRexx a une seule forme, plutôt que trois, et la gestion des exceptions peut être appliquée à tous les blocs plutôt que d'exiger une construction supplémentaire. De même, comme dans Rexx, toute allocation et désaffectation de stockage NetRexx est implicite - un nouvel opérateur explicite n'est pas requis.

En outre, les caractéristiques de Rexx (insensibilité à la casse pour les identificateurs, déduction de type à partir du contexte, conversions automatiques sécurisées, traçage et forte accentuation des représentations de valeurs communes et de nombres) rendent la programmation de l'environnement Java particulièrement facile. dans NetRexx.

Un hybride ou un tout?

Comme dans d'autres mélanges, tous les mélanges ne sont pas un succès; Lors de la première conception de NetRexx, il n'était pas du tout évident que la nouvelle langue serait une amélioration pour ses parents, ou refléterait simplement les pires caractéristiques des deux.

Le pivot de la conception est peut-être la manière dont le typage des données est automatisé sans perdre le typage statique supporté par Java. Typer dans NetRexx est le plus apparent aux interfaces - où il fournit le plus de valeur - mais dans les méthodes il est subordonné et n'obscurcit pas les algorithmes. Un concept simple, les classes binaires, permet également au programmeur de choisir entre une arithmétique décimale robuste et une arithmétique binaire moins sûre (mais plus rapide) pour une programmation avancée où la performance est une considération primordiale.

L'intégration «homogène» des types dans ce qui était auparavant un langage essentiellement sans typage semble avoir été un succès, offrant les avantages de la dactylographie forte tout en préservant la facilité d'utilisation et la rapidité de développement que Rexx les programmeurs ont apprécié.

Le résultat final de l'ajout de capacités de typage Java au langage Rexx est un langage unique qui a les atouts de Rexx pour écrire et écrire des macros pour les applications et les forces de robustesse, de bonne efficacité, de portabilité et de sécurité pour le développement d'applications.

Concepts linguistiques

Comme décrit dans la dernière section, NetRexx a été créé en appliquant la philosophie du langage Rexx à la sémantique requise pour la programmation de la machine virtuelle Java (JVM). Malgré l'hypothèse que la JVM est un «environnement cible» pour NetRexx, il est prévu que le langage ne dépende pas de l'environnement; l'essentiel de la langue ne dépend pas de la JVM. Les détails dépendants de l'environnement, tels que les types primitifs pris en charge, ne font pas partie de la spécification de langage.

Les concepts principaux de Rexx ont déjà été décrits dans le langage Rexx, mais il vaut la peine de les répéter et d'indiquer où des modifications et des ajouts ont été nécessaires pour soutenir les concepts d'environnements statiquement typés et orientés objet. Le reste de cette section est donc un résumé des principaux concepts de NetRexx.

Lisibilité

Un concept était au cœur de l'évolution de la syntaxe Rexx, et donc de la syntaxe NetRexx: la lisibilité (utilisée ici dans le sens de la lisibilité perçue). La lisibilité dans ce sens est une qualité quelque peu subjective, mais le principe général est que les jetons qui forment un programme peuvent être écrits comme on pourrait les écrire dans les langues d'Europe occidentale (anglais, français, etc.). Bien que NetRexx soit plus formel qu'un langage naturel, sa syntaxe est lexicalement similaire au texte de tous les jours.

La structure de la syntaxe signifie que le langage est facilement adapté à une variété de styles de programmation et de mises en page. Cela permet de satisfaire les préférences de l'utilisateur et permet une familiarité lexicale qui augmente également la lisibilité. Une bonne lisibilité améliore la compréhensibilité, ce qui réduit le nombre d'erreurs lors de l'écriture d'un programme et lors de la lecture pour des informations, le débogage ou la maintenance. Les facteurs importants ici sont:

  1. La ponctuation et d'autres notations spéciales ne sont requises que lorsque cela est absolument nécessaire pour supprimer l'ambiguïté (bien que la ponctuation puisse souvent être ajoutée en fonction de préférences personnelles, à condition qu'elle soit syntaxiquement correcte). Lorsque des notations sont utilisées, elles suivent des conventions établies.
  2. La langue est essentiellement insensible à la casse. Un programmeur NetRexx peut choisir un style d'utilisation de lettres majuscules et minuscules qu'il trouve plus utile (plutôt qu'un style choisi par un autre programmeur).
  3. Les constructions classiques de la programmation structurée et orientée objet sont disponibles dans NetRexx et peuvent sans aucun doute conduire à des programmes plus faciles à lire qu'ils ne pourraient l'être. La simplicité et le petit nombre de constructions font également de NetRexx un excellent langage pour l'enseignement des concepts de bonne structure.
  4. La liaison lâche entre les lignes physiques d'un programme et la syntaxe du langage assure que même si les programmes sont affectés par les fins de ligne, ils ne le sont pas irrévocablement. Une clause peut être répartie sur plusieurs lignes ou placée sur une seule ligne; Cette flexibilité aide un programmeur à définir le programme dans le style le plus lisible.

Typage de données naturel et arithmétique décimale



«Strong typage», dans lequel les valeurs qu'une variable peut prendre sont étroitement contraints, a été un attribut de certaines langues pendant de nombreuses années. Le plus grand avantage de la typage fort est pour les interfaces entre les modules du programme, où les erreurs sont faciles à introduire et difficiles à attraper. Les erreurs dans les modules qui seraient détectées par une forte typage (et qui ne seraient pas détectées par le contexte) sont beaucoup plus rares, certainement par rapport aux erreurs de conception, et dans la majorité des cas, ne justifient pas la complexité ajoutée du programme.

NetRexx traite donc les types aussi discrètement que possible, avec une syntaxe simple pour la description des types, ce qui facilite la définition des types aux interfaces (par exemple, lors de la description des arguments aux méthodes).

Par défaut, les valeurs communes (identificateurs, nombres, etc.) sont décrites sous la forme de la notation symbolique (chaînes de caractères) qu'un utilisateur écrirait normalement pour représenter ces valeurs. Ce type de données naturel pour les valeurs prend également en charge l'arithmétique décimale pour les nombres, donc, du point de vue de l'utilisateur, les nombres ressemblent et sont manipulés comme des chaînes, comme ils le seraient dans un usage quotidien sur papier.

Lorsque vous traitez des valeurs de cette manière, aucune représentation interne ou machine de caractères ou de nombres n'est exposée dans la langue, ce qui réduit le besoin de nombreux types de données. Il n'y a, par exemple, pas de concepts fondamentalement différents de l'entier et du réel; il y a juste le concept unique de nombre. Les résultats de toutes les opérations ont une représentation symbolique définie et agiront donc de manière cohérente et prévisible pour chaque implémentation correcte.

Ce concept sous-tend également le langage BASIC 7; En effet, la vision de Kemeny et Kurtz pour BASIC comprenait plusieurs des principes fondamentaux qui ont inspiré Rexx. Par exemple, Thomas E. Kurtz a écrit:

"En ce qui concerne les types de variables, nous avons estimé que la distinction entre" solidarités "et" flotter "était moins justifiée en 1964 que plus tôt ... à notre public potentiel la distinction entre un nombre entier et un nombre non entier semblerait ésotérique. Un nombre est un nombre est un nombre.â € 8

Pour Rexx, conçu comme un langage de script, cette approche était idéale; les opérations symboliques étaient tout ce qui était nécessaire.

Pour NetRexx, cependant, il est reconnu que pour certaines applications, il est nécessaire de tirer pleinement parti des performances de l'environnement sous-jacent, et donc le langage permet l'utilisation et la spécification des types arithmétiques et binaires, si disponibles. Un mécanisme très simple (déclarant qu'une classe ou une méthode est binaire) est fourni pour indiquer au processeur de langage que l'arithmétique binaire et les types doivent être utilisés, le cas échéant. Dans ce cas, comme dans d'autres langues, le programmeur doit faire très attention pour éviter de dépasser les limites de la taille des nombres et ainsi de suite.

Accent sur la manipulation symbolique

Beaucoup de valeurs que NetRexx manipule sont (du point de vue de l'utilisateur, au moins) sous la forme de chaînes de caractères. La productivité est grandement améliorée si ces chaînes peuvent être manipulées aussi facilement que la manipulation de mots sur une page ou dans un éditeur de texte. NetRexx dispose donc d'un riche ensemble d'opérateurs et de méthodes de manipulation de caractères, qui opèrent sur des valeurs de type Rexx (le nom de la classe des chaînes NetRexx).

La concaténation, l'opération de chaîne la plus courante, est traitée spécialement dans NetRexx. En plus d'un opérateur de concaténation classique (?), L'opérateur vierge de Rexx concatène deux chaînes de données avec un espace entre les deux. En outre, si deux termes syntaxiquement distincts (tels qu'une chaîne et un nom de variable) sont joints, les chaînes de données sont concaténées directement. Ces opérateurs facilitent particulièrement la création de chaînes de caractères complexes et peuvent à tout moment être combinés avec les autres opérateurs.

Par exemple, l'instruction say est constituée du mot-clé say suivi de toute expression. Dans cette instance de l'instruction, si la variable n a la valeur "6" alors dites "Désolé", n * 100/50 'ont été rejetés' afficherait la chaîne

Désolé, 12% ont été rejetés

La concaténation a une priorité inférieure à celle des opérateurs arithmétiques. L'ordre d'évaluation de l'expression est donc d'abord la multiplication, puis la division, puis la concaténation avec blanc, et enfin la concaténation directe.

Puisque les opérateurs de concaténation sont distincts des opérateurs arithmétiques, une coercition très naturelle (conversion automatique) entre les nombres et les chaînes de caractères est possible. De plus, la conversion explicite de types (conversion de types) est effectuée par les mêmes opérateurs, à la même priorité, ce qui rend la syntaxe très naturelle et cohérente pour changer les types de résultats. Par exemple,

i = int 100/7

calculerait le résultat de 100 divisé par 7, convertirait ce résultat en un entier (en supposant que int décrit un type entier), puis l'affecterait à la variable i.

Rien à déclarer

Conformément à la philosophie de la simplicité, NetRexx n'exige pas que les variables dans les méthodes soient déclarées avant utilisation. Seules les propriétés9 des classes - qui peuvent faire partie de leur interface avec d'autres classes - doivent être listées formellement.

Dans les méthodes, le type de variables est déduit statiquement du contexte, ce qui sauve le programmeur de la tâche subalterne d'énoncer explicitement le type. Bien sûr, si vous préférez, les variables peuvent être listées et affectées d'un type au début de chaque méthode.

Indépendance environnementale

Le langage NetRexx de base est indépendant des systèmes d'exploitation et du matériel. Cependant, les programmes NetRexx doivent être capables d'interagir avec leur environnement, ce qui implique une certaine dépendance vis-à-vis de cet environnement (par exemple, des représentations binaires de nombres peuvent être requises). Certaines zones de la langue sont donc décrites comme étant définies par l'environnement.

Là où l'indépendance de l'environnement est définie, cependant, il peut y avoir une perte d'efficacité - bien que cela puisse habituellement se justifier compte tenu de la simplicité et de la portabilité gagnées.

A titre d'exemple, la comparaison de chaînes de caractères dans NetRexx est normalement indépendante de la casse et des blancs de début et de fin. (La chaîne «Oui» signifie la même chose que «oui» dans la plupart des applications.) Cependant, l'influence du matériel sous-jacent a souvent subtilement affecté ce genre de décision de conception, de sorte que de nombreuses langues n'autorisent que les espaces de fin, mais pas les espaces vides, et insistent sur la correspondance exacte des cas. En revanche, NetRexx fournit la comparaison détendue axée sur l'homme pour les chaînes par défaut, avec optionnel "strict comparaison" opérateurs.

Unités syntaxiques à portée limitée

L'unité fondamentale de la syntaxe dans le langage NetRexx est la clause, qui est un morceau de texte de programme terminé par un point-virgule (généralement implicite à la fin d'une ligne). L'étendue des unités syntaxiques est donc petite, généralement une ligne ou moins. Cela signifie que l'analyseur de syntaxe dans le processeur de langage peut rapidement détecter et localiser les erreurs, ce qui signifie que les messages d'erreur peuvent être à la fois précis et concis.



Il est difficile de fournir de bons diagnostics pour les langages (comme le Pascal et ses dérivés) qui ont de grandes unités syntaxiques fondamentales. Pour ces langues, une petite erreur peut souvent avoir un effet majeur ou distribué sur l'analyseur, ce qui peut entraîner plusieurs messages d'erreur ou même des messages d'erreur trompeurs.

Faire face à la réalité

Un langage informatique est un outil à utiliser par de vraies personnes pour faire un vrai travail. Tout outil doit avant tout être fiable. Dans le cas d'un langage, cela signifie qu'il doit faire ce que l'utilisateur attend. Les attentes des utilisateurs sont généralement basées sur l'expérience antérieure, y compris l'utilisation de diverses langues de programmation et naturelles, et sur la capacité humaine à abstraire et à généraliser.

Il est difficile de définir exactement comment répondre aux attentes des utilisateurs, mais cela aide à poser la question "Y at-il un facteur d'étonnement élevé associé à cette fonctionnalité?". Si une caractéristique, accidentellement mal utilisée, donne des résultats apparemment imprévisibles, alors elle a un facteur d'étonnement élevé et n'est donc pas souhaitable.

Un autre attribut important d'un outil logiciel fiable est la cohérence. Un langage cohérent est par définition prévisible et est souvent élégant. Le danger ici est de supposer que parce qu'une règle est cohérente et facilement décrite, elle est donc simple à comprendre. Malheureusement, certaines des règles les plus élégantes peuvent conduire à des effets totalement étrangers à l'intuition et aux attentes d'un utilisateur qui, après tout, est humain.

Ces contraintes font de la conception de langages de programmation plus un art qu'une science, si l'utilisabilité de la langue est un objectif primordial. Les problèmes sont encore aggravés pour NetRexx parce que le langage convient à la fois pour les scripts (où le développement rapide et la facilité d'utilisation sont primordiaux) et pour le développement d'applications (où certains programmeurs préfèrent une vérification extensive et un codage redondant). Ces objectifs conflictuels sont équilibrés dans NetRexx en fournissant une gestion automatique de nombreuses tâches (telles que des conversions entre différentes représentations de chaînes et de nombres) tout en permettant des options «strictes» qui, par exemple, peuvent nécessiter que tous les types sont explicites, les identificateurs sont identiques en cas d'orthographe et ainsi de suite.

Être adaptable

Dans la mesure du possible, NetRexx permet l'extension des instructions et d'autres constructions de langage, en s'appuyant sur l'expérience acquise avec Rexx. Par exemple, il existe un ensemble utile de caractères communs disponibles pour une utilisation future, car seul un petit jeu est utilisé pour les quelques notations spéciales dans la langue.

De même, les règles de reconnaissance des mots clés permettent d'ajouter des instructions à tout moment sans compromettre l'intégrité des programmes existants. Il n'y a pas de mots-clés réservés dans NetRexx; Les noms de variables choisis par un programmeur ont toujours la priorité sur la reconnaissance des mots-clés. Cela garantit que les programmes NetRexx peuvent être exécutés en toute sécurité, à partir de la source, à un moment ou à un endroit distant de leur écriture originale - même si, entre-temps, de nouveaux mots-clés ont été ajoutés à la langue.

Un langage doit être adaptable car il sera certainement utilisé pour des applications non prévues par le concepteur. Comme tous les langages de programmation, NetRexx peut (en effet, probablement) s'avérer inadéquat pour certaines futures applications; de la place pour l'expansion et le changement est inclus pour rendre le langage plus adaptable et robuste.

Gardez la langue petite

NetRexx est conçu comme une petite langue. Ce n'est pas la somme de toutes les fonctionnalités de Rexx et de Java; les fonctionnalités inutiles ont plutôt été omises. L'intention a été de garder le langage aussi petit que possible, de sorte que les utilisateurs puissent rapidement saisir la majeure partie de la langue. Cela signifie que:

  • La langue semble moins redoutable au nouvel utilisateur

La documentation est plus petite et plus simple

 · l'utilisateur expérimenté peut être conscient de toutes les capacités de la langue, ainsi que tout l'outil à sa disposition

Il y a peu d'exceptions, de cas particuliers ou d'embellissements rarement utilisés

  • Le langage est plus facile à mettre en œuvre.

Beaucoup de langages ont ajouté des fonctionnalités «neat» qui rendent certains algorithmes plus faciles à exprimer; L'analyse montre que beaucoup d'entre eux sont rarement utilisés. En règle générale, les fonctionnalités qui fournissaient simplement d'autres manières d'écrire du code ont été ajoutées à Rexx et à NetRexx uniquement si elles étaient susceptibles d'être utilisées plus d'une fois sur cinq mille clauses.

Aucune limite de taille ou de forme définie

Le langage ne définit pas de limites sur la taille ou la forme de l'un de ses jetons ou données (bien qu'il puisse y avoir des restrictions d'implémentation). Cependant, il définit quelques exigences minimales qui doivent être satisfaites par une implémentation. Chaque fois qu'une restriction de mise en œuvre doit être appliquée, il est recommandé qu'elle soit d'une telle ampleur que peu d'utilisateurs (le cas échéant) seront affectés.

Lorsque des limites d'implémentation arbitraires sont nécessaires, le langage exige que l'implémenteur utilise des valeurs décimales familières et mémorables pour les limites. Par exemple, 250 serait utilisé de préférence à 255, 500 à 512, et ainsi de suite.



53