Analyser un langage de programmation

Dans SICP , les auteurs déclarent ( section 1.1 ) qu'il existe trois "mécanismes" de base des langages de programmation:

• les expressions primitives , qui représentent les entités les plus simples dont la langue s'occupe

• moyens de combinaison , par lesquels les éléments composés sont construits à partir de plus simples

• des moyens d'abstraction , par lesquels les éléments composés peuvent être nommés et manipulés comme des unités

Comment puis-je analyser un langage de programmation grand public (Java, par exemple) en termes de ces éléments ou mécanismes?

La distinction entre les expressions primitives, les moyens de combinaison et les moyens d'abstraction est utile lors de la modélisation des langages de programmation. Notez que ce n'est pas une propriété intrinsèque du langage: vous ne pouvez pas pointer sur une définition de langage et dire «cette caractéristique est sans ambiguïté une expression primitive, cette caractéristique est sans équivoque un moyen de combinaison». La distinction est une propriété du modèle et les modèles complexes peuvent résister à la classification.

Un exemple de manuel de ces trois concepts est le calcul lambda , qui a exactement l'un de chacun:

• Les variables x , y ,… sont les seules expressions primitives.
• L'application de fonction MN est le seul moyen de combinaison.
• L'abstraction lambda λx.M est le seul moyen d'abstraction.

Lorsque vous accédez à des langues avec plus de fonctionnalités, la modélisation peut devenir plus ambiguë. D'une manière générale, une expression primitive est une expression que vous ne pouvez pas ou ne voulez pas décomposer en composants primitifs. Mais c'est comme l' atome : il est primitif jusqu'à ce que la science avance. Par exemple, il existe une variante du lambda-calcul dans laquelle les variables utilisent des nombres plutôt que des noms ( indices de Bruijn ), ce qui est particulièrement pratique lors de la modélisation des termes lambda pour les preuves informatiques; et dans les épreuves informatiques, les entiers sont décomposés en parties constituantes . Donc, dans ces modèles, les variables ne sont pas des expressions primitives après tout.

Dans (un modèle typique de) Java, les expressions primitives sont principalement des constantes et des variables. Les moyens de combinaisons comprennent les nombreux opérateurs; plus précisément, l'expression «additive» est un moyen de combinaison avec deux emplacements (le côté gauche et le côté droit), ou avec trois emplacements (les deux côtés plus l'opérateur) si vous incluez à la fois A + B et A - B sous ce nom (auquel cas les opérateurs +et -seraient des constructions primitives à part entière). D'autres moyens de combinaison incluent des séquences d'instructions I ; J , des constructions de boucleswhile (…) {…}, etc. Ensuite, vous avez des constructions comme des déclarations de variables, des définitions de fonctions, des définitions de classe, etc. qui sont à la fois des moyens de combinaisons (ils combinent des noms et des types de paramètres, des corps, des initialiseurs,…) et des moyens d'abstraction (car ils définissent des noms à réutiliser). Il est en effet assez courant que les moyens d'abstraction soient aussi des moyens de combinaison: ils combinent un nom avec sa définition.

Coup de couteau brutal:

Les expressions ne sont que cela; ce qui constitue une expression en Java. Je ne sais pas si cela s'élargirait pour inclure des déclarations ou non.

Les combinaisons comprendraient des expressions composées, des instructions (variables?), Des méthodes, le mécanisme de classe et des packages. Les modules aussi, une fois qu'ils sont dans la langue.

En Java, le moyen d'abstraction le plus simple est une classe: rien ne peut exister en dehors d'une classe. Il existe peut-être des "couches" d'abstraction: une méthode statique est sans doute plus simple qu'une méthode d'instance, car elle ne nécessite pas d'instance.

Les génériques offrent une couche supplémentaire d'abstraction (et de frustration).

Voici ma catégorisation de base. J'essaie de dessiner un parallèle avec LISP.

Expressions primitives

• Toutes les valeurs primitives, les choses que vous pouvez représenter en utilisant des littéraux (nombres, booléens, ...)

Parallèle dans LISP : atomes, nombres et listes.

Moyens de combinaison (façons de créer des structures de données composées)

• Tableaux
• Objets / structures.

Parallèle dans LISP : Contre cellules, listes

Moyens d'abstraction

• Toutes les syntaxes de flux de contrôle (si, pendant pour)
• Tous les opérateurs de BUILTIN ( +, -, *, /, ...)
• Toutes les fonctions (dans cette catégorie, nous incluons les classes et les méthodes)

Parallèle dans LISP : Fonctions, sucre syntaxique comme let,define

Un langage de programmation est généralement défini par sa syntaxe et sa sémantique . Les deux seront définis dans les normes de la langue.

La syntaxe décrit comment écrire un programme valide et la sémantique définit ce que signifie ce programme valide.

Dans vos cas, la syntaxe vous dira quelles sont vos primitives, comment vous les combinez et comment vous les résumez. La sémantique vous dira ce que signifient les combinaisons et les abstractions.

Par exemple, la syntaxe vous indiquera comment écrire une forboucle valide . La sémantique vous dira ce que fait la boucle for.

Si vous voulez vraiment commencer à analyser un langage de programmation, prenez une copie de la norme et voyez ce qui s'y trouve. Je voudrais vraiment commencer avec un langage simple, comme C, avant de plonger dans Java. Je lirais également le reste du livre. Apprendre pourquoi les langages de programmation fonctionnent ainsi a fait de moi un meilleur programmeur, même si je n'implémente pas de compilateurs.

Je ne sais pas si c'est correct, mais la façon dont je comprends la division est la suivante:

expressions primitives , ce serait, des choses comme >>, +, *, /, int, booléen, variables, méthodes etc.

moyens de combinaison, cela peut être discutable, soit ses choses comme + et concact, ou son parler d'idées plus avancées comme l'héritage vs la composition et les méthodes pour le faire. Injection, le nouvel opérateur, extension etc.

moyens d'abstraction, ce serait la syntaxe utilisée pour nommer les variables et les méthodes, ainsi que les moyens de créer des interfaces, des classes, des classes statiques, des méthodes de surcharge, etc.

Cependant, il est possible que vous deviez nous donner plus d'informations sur le livre afin que nous sachions exactement ce que cela signifie.