Pourquoi les instructions dans de nombreux langages de programmation sont-elles terminées par des points-virgules?

Y a-t-il une raison pour laquelle un point-virgule a été choisi comme séparateur de ligne au lieu d'un symbole différent?

Je souhaite connaître l'historique de cette décision et espérer que les réponses permettront de mieux comprendre les décisions futures.

En anglais, le point-virgule est utilisé pour séparer les éléments d'une liste d'instructions, par exemple

Elle a vu trois hommes: Jamie, originaire de Nouvelle-Zélande; John, le fils du laitier; et George, un genre d'homme maigre.

Lors de la programmation, vous séparez un certain nombre d'instructions et utilisez un point complet peut facilement être confondu pour une virgule décimale. L'utilisation du point-virgule constitue une méthode d'analyse simple permettant de séparer les instructions de programme individuelles tout en restant proche de la ponctuation anglaise normale.

Modifier pour ajouter
Au début, lorsque la mémoire était chère, que le traitement était lent et que les premiers langages de programmation étaient en cours de conception, il était nécessaire de scinder le programme en instructions séparées. Certaines langues exigent que chaque instruction soit placée sur une ligne afin que le retour chariot puisse agir en tant que délimiteur d’instruction. D'autres langues permettaient un format plus libre pour la disposition du texte et nécessitaient donc un caractère de délimitation spécifique. Ce caractère a été choisi pour être le point-virgule, probablement en raison de la similarité de son utilisation en anglais (cela doit être une supposition; je n'étais pas là à l'époque) et comme il n'a pas produit de conflit avec l'autre ponctuation marques et symboles nécessaires à des fins mathématiques ou autres fins syntaxiques.

Modifier à nouveau
La nécessité d'un caractère de terminaison revient à la configuration requise pour analyser le texte de la langue. Les premiers compilateurs ont été écrits en langage assembleur ou, dans certains cas, directement dans des instructions machine binaires conçues à la main. Avoir un caractère spécial qui identifie la fin de l'instruction et délimite le bloc de texte en cours de traitement facilite grandement le traitement. Comme je l’ai dit plus haut, d’autres langues ont utilisé le retour chariot ou les crochets. Les groupes Algol, Pascal, Ada, BCPL, B, C, PL / M et d’autres familles de langues utilisent le point-virgule. Quant à savoir lequel a été le premier à utiliser ce personnage, je ne reviens pas assez loin dans l’histoire pour que je puisse m'en souvenir. Son choix et son adoption sont parfaitement logiques

• Son utilisation reflète l'utilisation d'une ponctuation anglaise normale.
• D'autres caractères (par exemple, le point final) peuvent prêter à confusion, car ils ont déjà une utilisation commune (un point final est également utilisé comme point décimal).
• Un caractère de ponctuation visible permet la mise en page de code au format libre.
• L'utilisation d'un caractère de délimitation similaire dans des langues dérivées ou ultérieures s'appuie sur la familiarité acquise par tous les programmeurs ayant utilisé la langue précédente.

Pour terminer, je pense que ces réponses et commentaires ont nécessité plus de temps que de décider d’utiliser le point-virgule pour mettre fin à une déclaration lors de la conception de la première langue qui l’utilisait de cette manière.

De nombreux langages utilisent une syntaxe qui est modelée sur C (qui a été modelée sur B - grâce à @Crollster). Comme on peut le voir dans les commentaires, il existe une longue chaîne de tels langages ... B s’inspire de PL / I, qui a été précédée par ALGOL en utilisant le ;comme séparateur.

Puisque le terminateur de déclaration est en C ;, ces langues font de même.

Pour ce qui est de la raison pour laquelle il a été sélectionné comme terminateur d’instruction en C - peut-être en raison de son utilisation en anglais, "pour indiquer des instructions interdépendantes" .

C a également été inventé sur le PDP-11 à une époque où la quantité de mémoire disponible pour les jeux de caractères était limitée. Les inventeurs des langues devaient donc respecter ces contraintes.

FORTRAN a utilisé un retour chariot pour délimiter des instructions. COBOL utilisé période. LISP n'utilisait rien, s'appuyant sur des parenthèses pour tout. ALGOL a été la première langue à utiliser le point-virgule pour séparer des instructions. PASCAL a suivi l'exemple d'ALGOL en utilisant un point-virgule pour séparer les instructions.

PL / I a utilisé un point-virgule pour terminer les déclarations. Il y a une différence et cela se voit facilement dans PASCAL. Ada a suivi l'exemple de PL / I sur celui-ci plutôt que celui d'ALGOL.

Le point-virgule en tant que séparateur ou terminateur d'instruction a rapidement été accepté par la communauté informatique comme une notation utile et, autant que je sache, tout langage subséquent structuré en blocs suivait l'exemple d'ALGOL et utilisait le point-virgule pour séparer ou terminer les déclarations.

On m'a dit, il y a de nombreuses années, que BCPL utilisait le point - virgule ET le retour chariot comme séparateurs / finisseurs de relevé, mais je n'ai jamais utilisé le langage moi-même et je ne peux pas le vérifier. À un moment donné, l'utilisation du retour chariot pour séparer ou mettre fin aux instructions a été supprimée des descendants de BCPL. BCPL a engendré B, B, C, C, C ++, Java, et bien d'autres choses beaucoup moins bien pensées que PASCAL et Ada.

Pourquoi pas un autre symbole?

Quelques langues ont utilisé d'autres symboles - les anciennes versions de BASIC utilisaient plutôt deux points, par exemple.

En ignorant les quelques exceptions, cependant, je pense qu'il y a deux raisons principales. La première est que vous recherchez simplement quelque chose sans ambiguïté. Dans un analyseur classique, si vous rencontrez une erreur suffisamment grave pour que vous ne puissiez plus analyser l’instruction en cours, vous essayez normalement de synchroniser l’analyseur en sautant simplement jusqu’au terminateur d’instruction et en le relançant à partir du début de la prochaine déclaration. Pour cela, vous voulez quelque chose qui ne se produira normalement nulle part ailleurs dans le code, et un point-virgule est un symbole avec peu de signification, il est donc assez facile de le dédier à cette fin.

La deuxième raison est un peu similaire, mais vise davantage les personnes qui lisent / utilisent le code. Encore une fois, cela revient au fait que le symbole que vous utilisez n'a pas beaucoup d'importance. La lisibilité présente un avantage substantiel en termes d'utilisation du symbole que votre lecteur est habitué à voir dans un but particulier, quand et si possible. Cela ne veut pas dire que C est la seule syntaxe parfaite et que tout le reste devrait suivre scrupuleusement, mais cela veut dire que suffisamment de gens connaissent ce style de syntaxe pour qu'un langage vaguement similaire gagne beaucoup (et perd très peu) en suivant à peu près la même syntaxe que possible.

Je tiens à noter que cela ressemble beaucoup à la conception de presque n'importe quel autre programme. Si j'écris un programme utilisant des fenêtres, j'essaierai d'utiliser uniquement les fonctionnalités natives de la ou des plates-formes cibles. Un grand nombre des décisions qui incarneront seront en grande partie arbitraires et pourraient être prises différemment sans perte majeure de fonctionnalité - mais de même, les modifier sans gain substantiel de fonctionnalité déroute simplement les utilisateurs sans rien accomplir d'utile. Les mêmes principes de base s'appliquent à "qu'est-ce qui devrait mettre fin (ou séparer) une déclaration dans une langue?" comme "à quoi devrait ressembler une barre de défilement", ou "comment un contrôle d'arborescence devrait-il fonctionner?" Dans tous ces cas, la décision est essentiellement arbitraire et l'uniformité procure un avantage substantiel en soi.

J'ajouterais que la même chose se produit dans de nombreuses langues, mais d'une manière à laquelle la plupart d'entre nous sommes tellement habitués avant la programmation que peu de gens y pensent. Pourquoi tout le monde utilise "+" pour indiquer l'addition ou "-" pour indiquer la soustraction? Parce que la forme du symbole importe peu, mais que tout le monde accepte d'appliquer la même signification à chaque symbole compte beaucoup.

Le point-virgule a été proposé à l'origine dans Algol 60 en tant que séparateur de déclaration et non de terminateur.

Avant Algol 60, le seul langage de programmation de haut niveau existant était Fortran, exigeant que chaque énoncé se trouve sur une ligne distincte. Les déclarations couvrant plusieurs lignes, comme les boucles de bouclage, étaient considérées comme une bizarrerie et considérées comme des «blocs de déclarations».

Les concepteurs d’Algol 60 ont compris que les instructions nécessitaient une structure hiérarchique (if-then-else, boucles, instructions majuscules, etc.) et qu’elles pouvaient être imbriquées les unes dans les autres. Donc, l'idée de chaque affirmation sur une ligne séparée n'a plus de sens. Composition séquentielle des déclarations de la forme S1; S2; ...; Sn éventuellement inclus dans les parenthèses début - fin ont été appelés déclarations composées , et s'inscrivent dans la structure hiérarchique des déclarations envisagées par Algol 60. Donc, ici, le point-virgule est clairement un séparateur de déclaration , pas un terminateur.

Cela a posé des problèmes dans la pratique. Algol 60 avait également une "déclaration vide" qui était indiquée par rien. Ainsi, on pourrait écrire " begin S1; end " où le point-virgule apparaît comme s'il terminait S1. Mais le compilateur Algol 60 l'a vraiment traité comme un séparateur entre S1 et une instruction vide invisible le suivant. Ces subtilités étaient un peu trop pour les programmeurs pratiques. Habitués à des langages linéaires comme Assembly et Fortran, ils ont vraiment pensé au point-virgule comme un terminateur des déclarations. Lorsque les programmes étaient écrits, le point-virgule était généralement placé à la fin des déclarations, comme suit:

    a [i]: = 0;
    i: = i + 1

et le point-virgule ressemblait vraiment à un terminateur pour la première déclaration. Si les programmeurs traitaient le point-virgule comme un terminateur, une telle instruction donnerait une erreur de syntaxe:

    si je> 0 alors
      a [i]: = 0;
    autre
      a [i]: = 1;

parce que le point-virgule termine le "si" et, ainsi, le "else" devient suspendu. Les programmeurs étaient complètement confus.

Ainsi, PL / I, qui a succédé à IBM Fortran, a décidé de faire du point-virgule un terminateur de déclaration plutôt qu'un séparateur. Les programmeurs étaient satisfaits de ce choix. La majorité des langages de programmation ont suivi. (Pascal a résisté à la tendance, mais son successeur Ada a abandonné.)

[Remarque ajoutée: l'article de Wikipedia sur les comparaisons de langages de programmation contient un tableau récapitulatif résumant la façon dont le point-virgule est traité dans divers langages de programmation.]

C'est un travail approximatif, mais si vous regardez un clavier QWERTY standard limité aux valeurs ASCII, les caractères naturels pour la terminaison / séparation seraient.!?,:; et la voiture revient. de ceux!?: devrait être immédiatement disqualifié pour la prise de plusieurs clés et la terminaison de relevé va être une chose très commune. Les périodes seraient disqualifiées car elles sont facilement confondues avec des points décimaux, ce qui les compliquerait inutilement pour devenir un terminateur compte tenu de l'espace limité des ordinateurs initiaux. les retours à la ligne seraient disqualifiés après que les lignes de code puissent potentiellement être plus longues que ce qui peut être affiché sur une seule ligne à l'écran, il serait donc plus difficile de lire un programme lorsque les lignes doivent défiler horizontalement, ou requièrent des caractères supplémentaires pour créer une continuation sur la ligne suivante, ce qui ajoute encore à la complexité. cela laisse, et; comme options, de celles-ci, est utilisé beaucoup plus souvent par écrit que; le point-virgule est donc choisi parce que c'est le type le plus facile à taper, moins déroutant, car il ajoute du sens à un caractère de signification limitée et moins compliqué, car il n'existe aucun cas spécial d'utilisation.

Le point-virgule a été choisi parce que c'était le meilleur personnage basé sur la paresse et la simplicité.

C'est en grande partie un choix arbitraire. Certaines langues ont fait d'autres choix. COBOL termine les instructions avec le .caractère. FORTRAN, BASIC et Python terminent généralement les instructions avec des nouvelles lignes (avec une syntaxe spéciale pour les instructions multilignes). Et Lisp met ses déclarations entre parenthèses.

La raison principale ;est si populaire en tant que séparateur / terminateur d'instruction, c'est que la plupart des langages populaires actuels sont basés sur ALGOL , qui utilisait cette convention.

au lieu d'un autre symbole?

Quel autre symbole pourriez-vous choisir?

Les caractères ASCII # $ @ [] ^ _ `{|} ~ n'étaient pas toujours présents dans les encodages de caractères précédents tels que ISO 646 .

Les caractères ()*+-/<=>sont généralement utilisés en tant qu’opérateurs mathématiques et créeraient des ambiguïtés lorsqu’ils seraient utilisés comme terminateurs d’instruction.

product = a * b *  // If '*' were a statement terminator,
c * d *            // Are there two factors, or four?

Des problèmes similaires s'appliqueraient à 'et ", qui sont généralement utilisés comme délimiteurs de chaîne; ,, qui est généralement utilisé pour séparer les arguments de la fonction, et ., qui est généralement utilisé comme un point décimal (ou comme un délimiteur dans des constructions similaires some_struct.some_field).

Ça part !%&:;?.

Choisir !ou ?ne causerait probablement pas de difficultés techniques, mais leur signification en anglais donnerait une mauvaise ambiance au programme.

print(x)?  # Yes, you should.
           # It's an IMPERATIVE language; stop questioning my commands.
print(x)!  # OK!  You don't have to shout!

Le &serait un choix plus judicieux en tant que séparateur d'instructions (pas de terminateur), car

do_thing_a() &
do_thing_b()

peut être lu comme une commande permettant de faire la chose A , puis la chose B. Mais la plupart des langages avec un &opérateur l’utilisent comme un AND logique ou binaire .

Le %signe peut causer de la confusion dans des énoncés tels que interest_rate = 2.99%(ce qui affecterait la variable à la 2.99place de celle attendue 0.0299). Bien sûr, la signification mathématique bien connue de %n'a pas empêché C de l'utiliser comme opérateur restant.

Alors ça part :et ;.

: est un choix judicieux, et est en effet utilisé comme séparateur d'instruction intra-ligne dans la plupart des dialectes de BASIC.

Mais ;a la grammaire anglaise de son côté; il peut être utilisé pour séparer des clauses dans une phrase.

Plutôt que d'essayer de répondre à votre question principale, je pense qu'il est préférable de vous concentrer sur votre question implicite:

Je souhaite connaître l'historique de cette décision et espérer que les réponses permettront de mieux comprendre les décisions futures en matière de conception et de mise en œuvre de langages de programmation.

Si vous souhaitez en savoir plus sur l'historique de la conception et de la mise en œuvre des langages de programmation et sur le processus, les débats des conférences sur l' historique des langages de programmation sont un très bon point de départ. (Je pense que vous aurez besoin d'une adhésion à ACM pour pouvoir accéder aux procédures cependant.)

Pourquoi les instructions dans de nombreux langages de programmation sont-elles terminées par des points-virgules? Y a-t-il une raison pour laquelle un point-virgule a été choisi comme séparateur de ligne au lieu d'un symbole différent?

Prenant votre question principale comme exemple de question à laquelle vous voudrez peut-être essayer de répondre en lisant les procédures de HOPL, je voudrais aborder le point suivant: les concepteurs d’un nouveau langage de programmation le font généralement parce qu’ils considèrent ceux qu’ils connaissent bien. cassé / déficient en quelque sorte. Leur nouveau langage est, d’une part, conçu pour remédier à cette lacune. D'autre part, les concepteurs de langage copieront également des éléments de conception d'autres langues qu'ils jugeront utiles ou ne changeront tout simplement pas les éléments avec lesquels ils n'ont pas rencontré de problèmes.

Cette dernière partie est particulièrement importante: au lieu d'essayer de déterminer quel langage de programmation a été le premier à utiliser les points-virgules comme terminateurs et pourquoi de nombreux autres langages de programmation l'ont copié, vous en apprendrez probablement plus en regardant des langages qui ne l'ont pas copié. il. Par exemple, bien que Smalltalk s’inspire beaucoup de Simula, il n’a pascopier sa syntaxe et en particulier son utilisation de points-virgules comme terminateurs d'instruction. Les terminateurs (les séparateurs) ont été complètement arrêtés, et le point-virgule a été utilisé pour autre chose. Inversement, la première langue qui utilisait un point-virgule comme terminateur de déclaration avait peut-être une raison de changer cela par rapport à ce qui était utilisé dans les langues antérieures. Il est également possible que ce soit la première langue à avoir introduit le concept entier de terminaison de déclaration (ou ce, indépendamment des autres langues) et que le point-virgule a été utilisé pour une raison qui est maintenant perdue dans le temps. (Je soupçonne que ce dernier cas est le cas ici, car aucun des autres répondants n'a été en mesure de trouver une citation de la personne qui a introduit le point-virgule plutôt que de proposer des suppositions réaménagées sur les raisons pour lesquelles le point-virgule était un bon choix.) point, Je pense que vous en apprendrez plus en examinant pourquoi les créateurs de langage ont changé les choses plutôt que pourquoi ils les ont copiés / conservés. Quand les gens changent des choses qu'ils veulent ou doivent expliquer habituellement, ils ne le font pas lorsqu'ils copient ou conservent les mêmes choses car «pourquoi changerions-nous? c'est comme ça que ça se passe!

C'est à propos de la visibilité.

Les premiers déclarations étaient les "." comme dans COBOL et nouvelle ligne, retour de chariot en FORTRAN.

Le CR s'est avéré limitant en ce sens qu'il est difficile de faire circuler une déclaration sur plusieurs lignes.

Un arrêt complet a provoqué un problème plus intéressant. Lorsque vous lisez du texte en anglais, votre cerveau traite les arrêts complets à un niveau subliminal, vous êtes conscient qu’une phrase est terminée et vous pouvez faire une pause pour respirer mais vous ne le remarquez pas vraiment. cela l'a signalé. Aussi dans beaucoup de polices le '.' est le plus petit caractère possible, parfois rendu sous forme de pixel unique. Les périodes manquantes ou supplémentaires sont devenues la principale cause d'erreur dans les programmes COBOL.

Tirer des leçons des premières erreurs, ALGOL a choisi un terminateur spécifique qui permettrait à une déclaration de s’écouler sur plusieurs lignes et en a choisi un qui soit visible et facilement repérable par les lecteurs. Le point-virgule étant à la fois assez grand et assez inhabituel en anglais commun pour ne pas être traité inconsciemment.

Je croyais comprendre que ce choix avait été choisi parce qu’il était nécessaire de disposer d’un terminateur d’instruction explicite autre qu’un retour à la ligne / nouvelle ligne. À l'époque des écrans à 80 colonnes, il était assez courant de placer une seule ligne de code sur plusieurs lignes pour que l'utilisation de \ r ou \ n comme terminateur d'instruction ne fonctionne pas.

Les points-virgules ne sont utiles que parce qu'ils ne sont pas utilisés dans les instructions logiques / mathématiques. En tant que tels, ils n'entrent pas en conflit avec le contenu réel des déclarations de manière significative.

Personnellement, je pense que l'utilisation continue du point-virgule, ainsi que des exigences de style pour conserver les lignes de moins de 80 caractères, sont franchement stupides et anachroniques. Des langages tels que python ont largement démontré que vous pouvez écrire du code facile à comprendre et concis plus facilement sans eux. De plus, si vous rencontrez des problèmes avec des lignes de plus de 80 caractères, vous avez besoin d'un moniteur plus grand.

Voici deux questions: Pourquoi ALGOL a-t-il un point-virgule et pourquoi d'autres langues l'ont-elles suivie?

La première question est déjà répondue à bien des égards ici.

En tant que deuxième, ALGOL était très largement utilisé comme langage pseudocode pour l'écriture d'algorithmes. Ainsi, les points-virgules sont vite devenus naturels pour les utilisateurs de différentes langues. Et naturellement, ils ont été pris pour les langues les plus jeunes.

Je me trompe peut-être, mais je pense que cela a quelque chose à voir avec le fait que dans beaucoup d'assembleurs, un point-virgule était utilisé pour commencer un commentaire, généralement placé après une instruction. Après tout, ;c’était un commentaire et non plus une partie de l’instruction elle-même.

Il est ensuite nécessaire de mettre fin aux instructions lorsque vous les tapez dans un interprète. Des instructions courtes (par exemple, des expressions mathématiques) peuvent être terminées en appuyant simplement sur la touche Entrée, en indiquant à l'interprète que l'expression est prête à être calculée et qu'elle produit un résultat. Mais parfois, on voulait entrer plusieurs lignes de code pour l'instruction. Un moyen d'y parvenir consistait donc à utiliser un caractère spécial comme terminateur de l'instruction au lieu de ne dépendre que de la touche Entrée. De cette façon, l’utilisateur pouvait entrer plus de lignes de code à la fois, car Enter ne l’avait pas encore envoyé à l’interprète. Ce n'est que lorsque l'interprète trouve le caractère de fin dans une ligne entrée avec Entrée qu'il l'exécute enfin et calcule son résultat.

Maintenant, combinez ces deux choses ensemble, et le point-virgule semble être un choix évident pour le caractère final: il indique où la partie instruction se termine et la partie commentaire commence. Ainsi, lorsque l'interprète le rencontre sur une ligne, il sait qu'il peut toutes les lignes de l'expression qu'il a tamponnée jusqu'ici et l'exécute, parce que l'instruction vient de se terminer, maintenant nous sommes dans un commentaire (enfin, au moins jusqu'à la fin de cette ligne, car la prochaine ligne commencera dans le code mode à nouveau, en commençant une nouvelle expression / instruction).

Cela suppose, bien entendu, que c’est vraiment le point-virgule qui a été utilisé pour les commentaires de la personne qui a eu l’idée de le réutiliser en tant que terminateur d’instruction. Si cela avait été un autre caractère, nous aurions pu nous retrouver avec un terminateur d'instruction différent.

Inb4: Non, ceci n'est pas un compte rendu historique. Je n'ai aucune preuve que ce soit la façon dont les points-virgules sont apparus. C'est juste comment j'imagine que cela aurait probablement pu arriver.

La plupart des langues prenaient le point-virgule car il était déjà largement utilisé à cette fin et sa modification n’avait aucun sens.

Et compte tenu des premières langues pour faire ce choix, vous devrez examiner quelles sont les alternatives. Lorsque vous concevez une langue, vous souhaitez que les caractères nécessaires soient disponibles et les jeux de caractères à cette époque étaient codés sur 6 bits, souvent avec des motifs réservés, souvent avec des caractères non définis (pour une occurrence ultérieure, pensez à la variantes nationales de la norme ISO-646 - la variante américaine est bien connue sous le nom ASCII - qui réutilise les codes pour les caractères "communs" tels que [, #ou $et en voit l'effet dans un contexte où il n'y a que la moitié moins de positions de code disponibles et des lettres et chiffres réservant plus de la moitié de ceux-ci).

Il n’existait probablement aucun autre caractère pouvant être utilisé comme séparateur d’énoncé aussi intuitivement ( .c’est probablement déjà le seul prétendant sérieux à ce critère) et sans introduire de difficultés d’expression ou d’analyse syntaxique à une époque où la théorie de l’analyse et de l’analyse était encore en cours d’élaboration ( .maintenant hors de question en raison de son utilisation en nombres réels).

L’utilisation du point-virgule est une autre raison du fait qu’il s’agit de l’un des caractères que nous n’avons pas besoin ni utilisé plus souvent.

Supposons que nous l'utilisions plus souvent comme nom de variable ou quelque chose et que si le point-virgule avait été utilisé comme mot clé ou comme opérateur, cela aurait été un conflit de symboles pour le compilateur; il était donc important d'utiliser un symbole qui n'est pas souvent utilisé dans le codage.

Je pense que les langages de programmation de style C l'ont rendu populaire et que les auteurs de nouveaux langages de programmation ne voulaient pas réinventer la roue et ils ont continué à l'utiliser, jusqu'à maintenant.