Pourquoi BASIC a-t-il utilisé des numéros de ligne?
Pourquoi les anciens BASIC (et peut-être d'autres langues) utilisaient-ils des numéros de ligne dans le code source?
Je veux dire, quels problèmes a-t-il (essayé de) résoudre?
BASIC doit être mis en contexte avec ses langues contemporaines: fortran précoce, cobol et Assembly.
À l'époque où j'étais barbotant sur l'assemblage 6502 sans étiquettes, cela signifiait que lorsque vous aviez besoin d'ajouter une instruction quelque part au milieu d'un code très compact (j'ai ajouté plus tard NOP s) vous aviez besoin de parcourir et de refaire toutes les adresses de saut. Cela prenait du temps.
Fortran était un système basé sur une ligne numérotée qui était antérieur à BASIC. À Fortran, les colonnes 1 à 5 étaient un numéro de ligne à utiliser pour les cibles de branchement. L'essentiel avec Fortran était que les compilateurs avaient tendance à être un peu plus intelligents que l'interpréteur BASIC et l'ajout de quelques instructions consistait simplement à perforer certaines cartes et à les placer dans le jeu au bon endroit.
BASIC, d'autre part, a dû garder toutes ses instructions ordonnées. Il n'y avait pas beaucoup de concept de "continuation de la ligne précédente". Au lieu de cela, dans Applesoft BASIC (l'un des dialectes largement utilisés que je connais et sur lequel je peux trouver des informations), chaque ligne en mémoire était représentée comme suit:
NN NN TT TT AA BB CC DD .. .. 00
Il avait deux octets pour l'adresse de la ligne suivante (NN NN). Deux octets pour le numéro de ligne de cette ligne (TT TT), puis une liste de jetons (AA BB CC DD .. ..) suivi du marqueur de fin de ligne (00). (Cela vient de page 84-88 de Inside the Apple // e )
Un point important à réaliser en regardant cette représentation de la mémoire est que les lignes peuvent être stockées dans la mémoire dans le désordre. La structure de la mémoire était celle d'une liste chaînée avec un pointeur "ligne suivante" dans la structure. Cela a facilité l'ajout de nouvelles lignes entre deux lignes - mais vous avez dû numéroter chaque ligne pour qu'elle fonctionne correctement.
Plusieurs fois, lorsque vous travailliez avec BASIC, vous travailliez en fait dans BASIC lui-même. En particulier, une chaîne donnée était soit un numéro de ligne et des instructions BASIC, soit une commande à l'interpréteur de base pour RUN ou LIST. Cela a permis de distinguer facilement le code des commandes - tout le code commence par des chiffres.
Ces deux informations identifient pourquoi les nombres ont été utilisés - vous pouvez obtenir beaucoup d'informations en 16 bits. Les étiquettes basées sur des chaînes prendraient beaucoup plus d'espace et sont plus difficiles à commander. Les nombres sont faciles à utiliser, compréhensibles et plus faciles à représenter.
Dialectes BASIC ultérieurs où vous n'étiez pas dans l'interprète a tout le temps été en mesure de supprimer toutes les lignes numérotées et à la place de numéroter les lignes qui étaient des cibles de branche. En effet, les étiquettes.
Sur les premiers micro-ordinateurs, l'édition était basée sur des lignes. Vous ne pouviez pas simplement vous déplacer librement dans le code source et modifier. Vous aviez une seule ligne au bas de l'écran où vous pouviez taper des commandes et entrer du code. Le reste de l'écran était des listes de codes en lecture seule et une sortie de commande. Si vous vouliez éditer disons la ligne 90 dans le programme, vous avez écrit "EDIT 90 "et le contenu de la ligne 90 est entré dans le tampon d'édition sur une seule ligne. Une fois la ligne modifiée modifiée, la liste des programmes a été mise à jour. Vous aviez donc besoin de numéros de ligne pour pouvoir éditer le programme.
Lorsque les éditeurs de code sont devenus plus avancés et vous ont permis de déplacer le curseur dans la liste de codes, vous n'avez plus besoin de numéros de ligne.
Si vous pensez aux dialectes BASIC des micro-ordinateurs domestiques 8 bits des années 80, ces ordinateurs n'avaient pas d'éditeurs de texte (sauf si vous avez acheté une application de traitement de texte). Il n'y avait aucun moyen d'avoir le code source du programme BASIC entier "ouvert dans un éditeur", comme vous le feriez lors de la programmation d'aujourd'hui. Le programmeur ne penserait même pas au programme comme un fichier de code source ou du texte, vraiment.
Exemple de problème
Donc, disons que vous avez un programme simple sans numéro de ligne dans votre tête:
FOR I=1 TO 42
PRINT I
NEXT I
Vous démarrez votre ordinateur. Vous avez une invite "prête" ou quelque chose comme ça, et un curseur assis à la ligne suivante. Cela ressemble beaucoup aux environnements REPL d'aujourd'hui de différents langages de script, mais pas vraiment aussi strictement basés sur des lignes, plus sur des écrans. Donc pas tout à fait comme les REPL d'aujourd'hui, mais proches.
Maintenant, si vous commencez à entrer dans le programme, vous pouvez obtenir une erreur après la première ligne, car l'interpréteur BASIC essaie de l'exécuter immédiatement (et de l'oublier), et cela n'a aucun sens sans NEXT pour terminer la boucle. Ce n'est pas un éditeur de texte où vous éditez du texte, c'est là que vous donnez des commandes à l'ordinateur!
Solution partielle
Vous avez donc besoin d'un moyen de dire, ceci est une ligne de programme, stockez-la! Vous pourriez avoir une commande spéciale ou juste un symbole indiquant que bon, c'est une ligne de programme, stockez-la. Imaginons ceci:
#FOR I=1 TO 42
#PRINT I
#NEXT I
Ok, maintenant notre interpréteur BASIC imaginaire a stocké le programme et vous pouvez l'exécuter. Mais maintenant, vous voulez modifier la ligne PRINT. Comment faites-vous? Vous n'êtes pas dans un éditeur de texte, vous ne pouvez pas simplement déplacer le curseur sur la ligne et la modifier. Ou vous voulez ajouter une autre ligne comme LET COUNT=COUNT+1 dans la boucle. Comment indiquez-vous où la nouvelle ligne doit être insérée?
Solution de travail
Les numéros de ligne résolvent cela d'une manière très simple, mais plutôt délicate. Si vous entrez une ligne de programme avec un numéro qui existe déjà, l'ancienne ligne est remplacée. Maintenant, l'environnement REPL basé sur écran devient utile, car vous pouvez simplement déplacer le curseur vers le programme listant à l'écran, éditez la ligne à l'écran et appuyez sur ENTREE pour la stocker. Il semble que vous modifiez la ligne, alors qu'en fait vous modifiez du texte à l'écran puis remplacez toute la ligne avec une nouvelle depuis l'écran. De plus, l'insertion de nouvelles lignes devient facile si vous laissez des nombres inutilisés entre les deux. Pour démontrer:
10 FOR I=1 TO 42
20 PRINT I
30 NEXT I
Après avoir entré à nouveau la ligne 20 avec des modifications et ajouté de nouvelles lignes,
5 LET COUNT=0
10 FOR I=1 TO 42
20 PRINT "Index", I
25 LET COUNT=COUNT+1
30 NEXT I
Plus de problèmes que nous venons de résoudre
Il y a l'avantage (ou la malédiction, car il active le célèbre code spaghetti BASIC) de pouvoir utiliser les numéros de ligne comme construction de langage, au moins comme cible des commandes GOTO ET GOSUB. Cela pourrait être remplacé par des étiquettes, mais l'utilisation de numéros de ligne est beaucoup plus simple à implémenter dans l'interpréteur BASIC, qui était toujours un avantage certain dans un ordinateur domestique 8 bits typique des années 80.
Plus important encore, du point de vue de l'expérience utilisateur, les numéros de ligne sont vraiment une interface étonnamment simple mais complète pour éditer le code. Tapez simplement une ligne commençant par un nombre pour insérer un nouveau code. Utilisation LIST 100-200 pour afficher les lignes 100-200. Pour modifier une ligne, répertoriez-la à l'écran, modifiez le texte à l'écran et entrez à nouveau la ligne. Pour supprimer une ligne, modifiez-la pour qu'elle soit vide, c'est-à-dire donnez simplement le numéro de ligne sans rien après. Un paragraphe pour décrire cela. Comparez essayer de décrire l'utilisation d'anciens éditeurs de texte comme edlin de DOS, ou ed ou ex d'Unix: vous avez besoin d'un paragraphe (seulement une légère hyperbole) juste pour expliquer comment l'utilisateur peut les quitter, lorsqu'il est démarré accidentellement!
Conclusion
D'autres réponses expliquent comment les numéros de ligne ont été créés. J'essaie de couvrir ici, pourquoi les numéros de ligne ont survécu aussi longtemps, comment ils ont continué à résoudre un problème du monde réel: ils ont offert un moyen de faire la programmation réelle sans véritable éditeur, d'une manière très simple. Une fois que les éditeurs de texte en plein écran appropriés et faciles à utiliser sont devenus le moyen principal d'éditer le code, à la fois avec les limitations matérielles disparaissant et lorsque l'inertie des personnes adaptant de nouvelles choses a été surmontée, les dialectes BASIC basés sur le numéro de ligne ont assez rapidement disparu de l'utilisation, car le problème de convivialité qu'ils ont résolu n'était plus un problème.
À l'époque et à l'époque où Basic a été développé, le meilleur périphérique d'E/S disponible était un télétype. La modification d'un programme a été effectuée en imprimant (sur papier) une liste de l'ensemble du programme, ou de la partie intéressante de celui-ci, puis en tapant les lignes de remplacement avec des numéros de ligne.
C'est aussi pourquoi la numérotation des lignes par défaut était de 10, donc il y aurait des numéros inutilisés entre les lignes existantes.
"Numéros de ligne" signifie plusieurs choses différentes.
Tout d'abord, gardez à l'esprit que le concept de "lignes" n'existe pas depuis toujours. De nombreux langages de programmation de cette époque utilisaient des cartes perforées , et avaient des numéros de séquence (généralement dans les dernières colonnes de la carte) vous a aidé à récupérer votre jeu dans le bon ordre si vous le laissiez tomber ou si quelque chose de terrible se produisait dans le lecteur de carte. Il y avait des machines pour le faire automatiquement.
Les numéros de ligne à utiliser comme cibles des instructions GOTO sont un concept totalement différent. Dans FORTRAN IV, ils étaient facultatifs et précédaient l'énoncé (dans les colonnes 1 à 5). En plus d'être plus facile à implémenter que les étiquettes de forme libre, il y avait aussi le concept de GOTO calculé et attribué , qui vous permettait de passer à un numéro de ligne arbitraire. C'était quelque chose que la plupart des langages de programmation modernes n'ont pas (bien que les instructions switch se rapprochent), mais c'était une astuce familière pour les programmeurs assembleurs.
BASIC est dérivé de FORTRAN, et destiné à être plus simple à implémenter et à comprendre, forçant ainsi chaque "ligne" à avoir un numéro de ligne (à la fois pour le séquençage et comme cible de GOTO/GOSUB déclarations) était probablement une décision de conception prise pour cette raison.
J'ai commencé la programmation en COBOL qui utilisait les numéros de ligne dans les colonnes 1-6 de chaque ligne. Parce qu'il n'y avait pas d'IDE dans les années 1970, tout a été fait via des cartes perforées et le numéro de ligne a été utilisé pour identifier les lignes de la source d'origine à remplacer et les nouvelles lignes ajoutées. Nous avions l'habitude d'incrémenter les numéros de ligne de 100 pour nous donner de l'espace pour ajouter plus de lignes.
BASIC est apparu plus tard que FORTRAN, à l'ère des terminaux de ligne. Il comportait un environnement de lecture-exe-impression-boucle qui était plus interactif qu'un jeu de cartes.
J'ai appris à programmer, en BASIC, sur un affichage sur une ligne qui contenait 24 caractères. Les numéros de ligne étaient un moyen naturel de spécifier où vous vouliez qu'une ligne aille, qu'il s'agisse d'en modifier une ou de l'insérer entre d'autres.
Je ne peux vraiment pas imaginer comment vous le feriez autrement.
Le système de partage du temps de Dartmouth a utilisé une interface de télétype. Il a donc utilisé une interface basée sur des commandes. À l'origine, les numéros de ligne étaient simplement utilisés comme moyen de modifier le programme. Vous pouvez insérer, remplacer ou supprimer en utilisant un numéro de ligne. Il ne semble pas que la première version utilisait des numéros de ligne pour les instructions goto, mais c'était un ajout ultérieur à la langue.
Un point que personne n'a encore mentionné est qu'il est plus facile pour les débutants de raisonner sur le déroulement du programme lorsque les cibles de branche sont explicites. Donc, plutôt que d'avoir à faire correspondre (éventuellement imbriqué) les instructions BEGIN/END (ou quels que soient les délimiteurs de bloc utilisés), il était assez évident où le flux de contrôle allait. Cela était probablement utile compte tenu du public cible de BASIC (il s'agit du Débutant Code d'instruction symbolique polyvalent, après tout).