TUTEUR - TUTOR
Paradigme | impératif ( procédure ) |
---|---|
Conçu par | Paul Tenczar & Richard Blomme |
Développeur | Paul Tenczar & Université de l'Illinois à Urbana-Champaign |
Première apparition | 1969 |
Discipline de frappe | rien |
Les principales mises en œuvre | |
TUTEUR, Micro-TUTEUR | |
Influencé | |
TenCORE , UTILISATION ( Systèmes Regency ) |
TUTOR , également connu sous le nom de PLATO Author Language , est un langage de programmation développé pour être utilisé sur le système PLATO à l' Université de l'Illinois à Urbana-Champaign à partir d'environ 1965. TUTOR a été initialement conçu par Paul Tenczar pour être utilisé dans l'enseignement assisté par ordinateur (CAI) et l'instruction gérée par ordinateur (CMI) (dans des programmes informatiques appelés « leçons ») et possède de nombreuses fonctionnalités à cet effet. Par exemple, TUTOR dispose de puissantes commandes, graphiques et fonctionnalités d'analyse et d'évaluation des réponses pour simplifier la gestion des dossiers des étudiants et des statistiques par les instructeurs. La flexibilité de TUTOR, combinée à la puissance de calcul de PLATO (fonctionnant sur ce qui était considéré comme un superordinateur en 1972), le rendait également adapté à la création de jeux - y compris des simulateurs de vol, des jeux de guerre, des jeux de rôle multijoueurs de style donjon, des jeux de cartes, des jeux de mots des jeux et des jeux de cours médicaux tels que Bugs and Drugs ( BND ). TUTOR est toujours le langage de programmation du système Cyber1 PLATO, qui exécute la plupart du code source de PLATO des années 1980 et compte environ 5 000 utilisateurs en juin 2020.
Origines et développement
TUTOR a été développé à l'origine comme un langage de création à usage spécial pour la conception de leçons pédagogiques, et son évolution vers un langage de programmation à usage général n'était pas planifiée. Le nom TUTOR a été appliqué pour la première fois à la langue de création du système PLATO dans les derniers jours de Platon III. La première documentation du langage, sous ce nom, semble avoir été The TUTOR Manual , CERL Report X-4, par RA Avner et P. Tenczar, janvier 1969.
L'article Enseigner la traduction du russe par ordinateur donne un aperçu de TUTOR peu de temps avant que PLATO IV ne soit opérationnel. Les éléments de base du langage étaient présents, mais les commandes étaient données en majuscules, et au lieu d'utiliser un mécanisme général, la prise en charge des jeux de caractères alternatifs se faisait via des noms de commandes spéciaux tels que WRUSS
« écrire en utilisant le jeu de caractères russes ».
Au cours des années 1970, les développeurs de TUTOR ont profité du fait que l'ensemble du corpus des programmes TUTOR était stocké en ligne sur le même système informatique. Chaque fois qu'ils ressentaient le besoin de changer de langue, ils exécutaient un logiciel de conversion sur le corpus de code TUTOR pour réviser tout le code existant afin qu'il soit conforme aux modifications qu'ils avaient apportées. En conséquence, une fois les nouvelles versions de TUTOR développées, le maintien de la compatibilité avec la version PLATO pourrait être très difficile.
Control Data Corporation (CDC), en 1981, avait largement supprimé le nom TUTOR de leur documentation PLATO. Ils appelaient la langue elle-même la langue de l' auteur PLATO . L'expression fichier TUTOR ou même fichier de leçon TUTOR a cependant survécu en tant que nom du type de fichier utilisé pour stocker le texte écrit dans le langage PLATO Author Language.
Structure d'une leçon TUTOR
Une leçon TUTOR consiste en une séquence d' unités où chaque unité commence par la présentation d'informations et la progression d'une unité à l'autre dépend de la réponse correcte à une ou plusieurs questions. Comme avec les paragraphes COBOL , le contrôle peut entrer une unité TUTOR à partir de l'unité précédente et sortir dans la suivante, mais les unités peuvent également être appelées en tant que sous-programmes en utilisant les commandes
do
oujoin
Voici un exemple d'unité de la page 5 du TUTOR User's Memo , mars 1973 ( Computer-based Education Research Laboratory , University of Illinois at Urbana-Champaign ) :
unit math
at 205
write Answer these problems
3 + 3 =
4 × 3 =
arrow 413
answer 6
arrow 613
answer 12
Plusieurs choses devraient être immédiatement apparentes à partir de cet exemple.
- Premièrement, TUTOR est un langage à format fixe. Chaque ligne commence par un nom de commande, qui doit tenir dans un champ fixe de 8 caractères pour le nom de la commande. Les arguments de cette commande (la balise ) commencent au 9e caractère. Bien qu'une touche de tabulation ait été utilisée pour accéder à la 9ème colonne, elle a généré des espaces car platon n'avait pas de caractère de tabulation.
- Dans certains cas, comme la
write
commande ci-dessus, la balise peut être constituée de plusieurs lignes. Les lignes de suite sont soit vides, soit comportent une tabulation de début. - Les coordonnées de l'écran sont présentées sous forme de nombres simples, donc 205 fait référence à la ligne 2 colonne 5 et 413 fait référence à la ligne 4 colonne 13.
Ce qui peut ne pas être apparent, c'est la structure de contrôle implicite dans cette unité. La arrow
commande marque l'entrée d'un bloc de jugement. Cette structure de contrôle est l'une des caractéristiques uniques de TUTOR.
Caractéristiques uniques
TUTOR contenait un certain nombre de fonctionnalités uniques. La liste suivante n'est pas destinée à remplacer un manuel TUTOR, mais met simplement en évidence les caractéristiques les plus intéressantes, innovantes et parfois déroutantes du langage.
Jugement de la réponse
Un bloc de jugement dans TUTOR est une structure de contrôle qui commence par une arrow
commande et se termine par la suivante arrow
, endarrow
ou unit
commande. La arrow
commande invite également à entrer, avec le caractère de flèche spécial (ressemblant à "▷") affiché comme invite aux coordonnées d'écran indiquées. En effet, un bloc de jugement peut être considéré comme une structure de contrôle de retour en arrière où l'étudiant peut faire plusieurs tentatives pour répondre à une question jusqu'à ce qu'une réponse correcte permette de progresser.
Jugement de la correspondance des modèles
Chaque bloc de jugement consiste en une séquence de commandes de correspondance de motifs , chacune d'elles introduisant un bloc (éventuellement vide) de commandes à exécuter si ce motif correspond. Les deux commandes de correspondance de modèles les plus courantes étaient answer
et wrong
. Ceux-ci avaient une sémantique de correspondance de modèle identique, sauf qu'ils answer
jugeaient une réponse d'étudiant correcte si elle correspondait, tandis wrong
qu'une réponse d'étudiant était jugée incorrecte.
Les champs de balise sur les commandes answer
et wrong
consistaient en des listes de mots facultatifs, obligatoires et alternatifs. Considérez cet exemple tiré de l'exercice 4-1 du Mémo de l'utilisateur du TUTEUR de 1973 :
answer <it, is,a, it's, figure,
polygon>
(right, rt) (triangle, triangular)
Cela correspondrait à des réponses telles que "c'est un triangle rectangle" ou "c'est une figure triangulaire" ou simplement "rt triangle". Cela ne correspondrait pas à "sorte de triangulaire" car les mots "sorte de" ne sont pas répertoriés comme ignorés, et cela ne correspondrait pas à "triangle, n'est-ce pas ?" car la commande est erronée.
Le sous-système de correspondance de motifs reconnaissait les fautes d'orthographe, de sorte que les mots « triangel » ou « triangl » correspondraient au modèle d'exemple. L'auteur de la leçon pouvait utiliser la specs
commande pour définir le degré de pédantisme du système concernant les fautes d'orthographe.
Les algorithmes de correspondance de motifs utilisés par diverses implémentations de TUTOR variaient en détail, mais généralement, chaque mot du texte d'entrée et chaque mot du motif étaient convertis en vecteurs binaires . Pour voir si un mot d'entrée d'étudiant correspondait à un mot du motif, la distance de Hamming entre les deux vecteurs de bits a été utilisée comme mesure du degré de différence entre les mots. Les vecteurs de bits étaient généralement longs de 60 ou 64 bits, avec des champs pour la présence de lettres, la présence de paires de lettres et la première lettre. En conséquence, le nombre d'un bit dans l' exclusif ou de deux de ces vecteurs de bits approchait l'étendue de la différence phonétique entre les mots correspondants.
Juger les structures de contrôle
Toutes les premières présentations de la structure de contrôle d'un bloc de jugement TUTOR étaient déroutantes. En termes modernes, cependant, un bloc de jugement peut être décrit comme une structure de contrôle itérative qui sort lorsque la contribution de l'étudiant est jugée correcte. Le corps de cette structure de contrôle se compose d'une série de cas , chacun introduit par une commande de correspondance de modèle telle que answer
ou wrong
. Toutes les sorties produites par le corps de la boucle de jugement dans le cycle précédent sont effacées de l'écran avant le cycle suivant.
Considérez cet exemple, tiré de l'exercice 4-1 du Mémo de l'utilisateur du TUTEUR de 1973 :
wrong <it, is,a> square
at 1501
write A square has four
sides.
Dans le cas où l'élève saisit « carré » ou « un carré », la réponse est jugée incorrecte et le texte « Un carré a quatre côtés ». est émis à partir de la ligne 15 colonne 1 sur l'écran. Cette sortie reste à l'écran jusqu'à ce que l'étudiant commence à entrer une nouvelle réponse, après quoi elle est effacée afin que la réponse à la nouvelle réponse puisse être calculée. Le mécanisme par lequel l'écran d'affichage revient à son état précédent varie d'une implémentation à l'autre. Les premières implémentations fonctionnaient en basculant le terminal en mode effacement et en réexécutant l'intégralité du cas correspondant. Certaines implémentations ultérieures ont mis en mémoire tampon la sortie produite pendant le jugement afin que cette sortie puisse être effacée.
La join
commande était une forme unique d'appel de sous-programme. Il a été défini comme étant équivalent à la substitution textuelle du corps de l'unité jointe à la place de la commande de jointure elle-même (page 21, 1973 TUTOR User's Memo ). En tant que telle, une unité jointe pourrait contenir une partie d'un bloc de jugement. Ainsi, alors que le bloc de jugement est conceptuellement un itérateur renfermant une série de cas , ce bloc peut être arbitrairement divisé en sous-programmes. (Un appel de sous-programme alternatif, la do
commande, était conforme à la sémantique habituelle associée aux appels de sous-programme dans d'autres langages de programmation.)
Commandes graphiques et d'affichage
Le terminal étudiant PLATO IV avait un écran plasma de 512 par 512 pixels , avec un support matériel pour le traçage des points , le dessin au trait et l'affichage de texte. Chaque pixel du terminal PLATO IV était soit orange, soit noir. Le terminal CDC PLATO V utilisait un tube cathodique noir et blanc monochrome pour émuler le panneau plasma. Le jeu de caractères intégré avait 4 jeux de 63 caractères, chacun de 8 par 16 pixels, la moitié d'entre eux étaient fixes, la moitié étaient programmables. Le langage Tutor a fourni un support complet pour ce terminal.
Il y avait deux systèmes de coordonnées (voir page II-1 de The TUTOR Language de Bruce Sherwood) :
- Les coordonnées grossières ont été spécifiées en termes de lignes et de colonnes de texte. La coordonnée grossière 1501, par exemple, était une référence au caractère 1 de la ligne 15, où le caractère supérieur gauche de l'écran était à l'emplacement 101 et le caractère inférieur droit était à 3264.
- Les coordonnées fines ont été spécifiées sous forme de coordonnées X et Y par rapport au coin inférieur gauche de l'écran. La coordonnée fine 0,511 spécifiait le coin supérieur gauche de l'écran, tandis que 0,496 équivalait à la grossière 101, tenant compte de la hauteur de 16 pixels d'un caractère et du fait que les caractères étaient tracés par rapport à leur coin inférieur gauche.
Commandes de dessin
L'exemple suivant illustre certaines des commandes de dessin de Tutor.
draw 1812;1852;skip;1844;1544
circle 16,344,288
draw 1837;1537;1535;1633;1833
Notez l'utilisation de points-virgules pour séparer les coordonnées successives sur la draw
commande. Cela permet une utilisation sans ambiguïté de coordonnées fines séparées par des virgules. Normalement, la commande de dessin relie des points consécutifs avec des segments de ligne, mais en insérant skip
la balise, la draw
commande pourrait être amenée à soulever conceptuellement son stylo.
Les balises sur la circle
commande donnent le rayon et les coordonnées fines du centre. Des balises supplémentaires pourraient spécifier les angles de début et de fin pour les cercles partiels.
La composition manuelle des commandes de dessin est difficile, c'est pourquoi un éditeur d'images a été inclus dans le système PLATO en 1974 pour automatiser ce travail. Cela ne pouvait traiter que les commandes de dessin avec des coordonnées constantes.
Commandes de rendu de texte
L'exemple suivant illustre certains des outils de rendu de texte de Tutor.
unit title
size 9.5 $$ text 9.5 times normal size
rotate 45 $$ text rotated 45 degrees
at 2519
write Latin
size 0 $$ return to normal writing
rotate 0
at 3125
write Lessons on Verbs
Le texte rendu en taille zéro rotation zéro utilisait le matériel de rendu de caractères intégré du terminal PLATO, tandis que le rendu avec une taille et une rotation non nulles était effectué avec des segments de ligne et donc nettement plus lent en raison de la vitesse de la liaison de communication avec le terminal.
Structures de contrôle
Mis à part ses mécanismes uniques d'évaluation des réponses, l'ensemble original de structures de contrôle de TUTOR était plutôt clairsemé. Au milieu des années 1970, cette lacune a été corrigée en introduisant if
, des endif
blocs avec des sections facultatives elseif
et else
. La sémantique de ces structures de contrôle était routinière, mais la syntaxe héritait de l' indentation obligatoire du langage Tutor, présageant celle de Python et ajoutant un caractère d'indentation non vide unique pour distinguer l'indentation des lignes de continuation.
Ceci est illustré dans l'exemple suivant, tiré de la page S5 du Summary of TUTOR Commands and System Variables (10th ed) par Elaine Avner , 1981 :
if n8<4
. write first branch
. calc n9⇐34
elseif n8=4
. write second branch
. do someunit
else
. write default branch
. if n8>6
. . write special branch
. endif
endif
(La flèche d' affectation dans l' calc
instruction n'est pas rendue correctement dans certains navigateurs. Elle ressemble à <= mais sous la forme d'un seul caractère. Elle avait une touche dédiée sur le clavier PLATO IV.)
La même syntaxe a été utilisée pour loop
, des endloop
blocs avec une sémantique comparable à boucles while dans les langages de programmation classiques. Ceci est illustré dans l'exemple suivant, à partir de la page S6 du Résumé des commandes TUTOR et des variables système (10e édition) par Elaine Avner, 1981 :
loop n8<10
. write within loop
. sub1 n8
reloop n8≥5
. write still within loop
. do someunit
outloop n8<3
. write still within loop
endloop
write outside of loop
Notez que les commandes reloop
and outloop
sont quelque peu analogues aux instructions continue
and break
des langages basés sur C , sauf qu'elles doivent se situer au niveau d'indentation de la boucle qu'elles modifient, et qu'elles ont une balise de condition qui indique quand le transfert de contrôle indiqué doit avoir lieu . Cela rend la construction plus puissante que dans d'autres langages, car n'importe quelle ligne de la boucle interne peut se terminer ou reboucler plusieurs boucles externes avec une seule instruction.
Syntaxe d'expression
La syntaxe d'expression de TUTOR ne revenait pas à la syntaxe du FORTRAN et n'était pas non plus limitée par les jeux de caractères mal conçus de l'époque. Par exemple, le jeu de caractères PLATO IV incluait des caractères de contrôle pour l' indice et l'exposant , et TUTOR les utilisait pour l'exponentiation. Considérez cette commande (de la page IV-1 de The TUTOR Language , Sherwood, 1974) :
circle (412+72.62)1/2,100,200
Le jeu de caractères comprenait également les symboles conventionnels pour la multiplication et la division, ×
et ÷
, mais dans une dérogation plus radicale aux conventions établies par FORTRAN, il permettait la multiplication implicite, de sorte que les expressions (4+7)(3+6)
et étaient valides, avec les valeurs 99 et 15,9, respectivement (op cit). Cette caractéristique était considérée comme essentielle. Lorsque les étudiants tapaient une réponse numérique à une question, ils pouvaient utiliser des opérateurs et des variables et une notation algébrique standard, et le programme utilisait la commande TUTOR « calculer » pour compiler et exécuter la formule et vérifier qu'elle était numériquement équivalente (ou dans le erreur d'arrondi à virgule flottante) à la bonne réponse.
3.4+5(23-3)/2
Le langage comprenait une constante prédéfinie nommée avec la lettre grecque pi (π), avec la valeur appropriée, qui pouvait être utilisée dans les calculs. Ainsi, l'expression pourrait être utilisée pour calculer l'aire d'un cercle, en utilisant la constante π intégrée, la multiplication implicite et l'exponentiation indiquées par un exposant.
πr2
Dans TUTOR, la comparaison à virgule flottante x=y
était définie comme étant vraie si x
et y
étaient approximativement égales (voir page C5 de PLATO User's Memo, Number One par Avner, 1975). Cela simplifiait la vie des développeurs mathématiquement naïfs de leçons pédagogiques, mais causait parfois des maux de tête aux développeurs de code numériquement sophistiqué, car il était possible que les deux x<y
et x≥y
puissent être vrais en même temps.
Gestion de la mémoire
En tant que langage auteur, TUTOR a commencé avec seulement des ressources mémoire minimales et seulement les outils les plus grossiers pour les manipuler. Chaque processus utilisateur avait un segment de données privé de 150 variables, et des blocs communs partagés pouvaient être attachés, permettant la communication entre les utilisateurs via la mémoire partagée.
Sur le système PLATO IV, les mots étaient de 60 bits, conformément à la famille d'ordinateurs CDC 6600 . Certaines implémentations ultérieures ont changé cela en 64 bits.
Ressources mémoire de base
La région de mémoire privée de chaque processus se composait de 150 mots chacun, appelés variables d'étudiant; les valeurs de ces variables étaient persistantes, suivant l'utilisateur individuel de session en session. Ceux-ci ont été adressés comme à n1
travers n150
lorsqu'ils sont utilisés pour contenir des valeurs entières, ou comme à v1
travers v150
lorsqu'ils sont utilisés pour contenir des valeurs à virgule flottante.
Une leçon TUTOR pourrait attacher une seule région de jusqu'à 1500 mots de mémoire partagée à l'aide de la common
commande. Chaque leçon peut avoir un bloc commun temporaire sans nom contenant des variables partagées par tous les utilisateurs de cette leçon. De tels blocs étaient créés lorsqu'une leçon était utilisée et libérés lorsque la leçon devenait inactive. En revanche, les blocs communs nommés étaient associés à un bloc d'une leçon (un fichier disque). La mémoire partagée a été adressée comme nc1
par nc1500
(pour les entiers) ou vc1
par vc1500
(pour les nombres à virgule flottante).
Lorsque 150 variables d'élèves étaient insuffisantes, une leçon pouvait utiliser la
storage
commande pour créer un segment de mémoire privée supplémentaire pouvant aller jusqu'à 1000 mots. Ce segment n'existait que dans l'espace d'échange, mais il pouvait être mappé à des variables d'étudiant ou à des variables communes. Par exemple (à partir de la page X-11 de The TUTOR Language , Sherwood, 1974) :
common 1000
storage 75
stoload vc1001,1,75
Cet exemple définit nc1
to nc1000
comme un bloc commun sans nom partagé, tandis que nc1001
to nc1075
est un stockage privé.
Définir des noms symboliques
La define
commande Tutor était très similaire à la directive du préprocesseur C. C'était le seul moyen d'associer des noms mnémoniques à des variables. C'était au programmeur d'allouer statiquement de la mémoire et d'attribuer des noms aux variables. Considérez cet exemple de la page 17 du TUTOR User's Memo -- Introduction to TUTOR , 1973"
#define
define mynames
first=v1, second =v2
result=v3
Cela crée un ensemble de définitions nommées mynames
définissant trois variables à virgule flottante. Les utilisateurs ont été informés qu'« il ne devrait pas y avoir de v3 ou de v26 dans votre leçon, sauf dans l' define
énoncé lui-même . Mettez toutes vos définitions au tout début de la leçon où vous aurez une référence immédiate aux variables que vous utilisez. (souligné de l'original, page IV-5 de The TUTOR Language , Sherwood, 1974.)
Des fonctions pourraient être définies, avec une sémantique de macro-substitution, comme dans cette illustration de la page IX-2 de The TUTOR Language , Sherwood, 1974 :
define cotan(a)=cos(a)/sin(a)
Contrairement à C, les règles de portée originales de TUTOR étaient une pure "définition avant utilisation" sans aucune disposition pour les définitions locales. Ainsi, le paramètre formel a
utilisé ci-dessus ne doit pas avoir de définition préalable.
Plus tard dans le développement de TUTOR, avec l'introduction de plusieurs ensembles de définitions nommés, le programmeur a reçu un contrôle explicite sur les ensembles de définitions actuellement en vigueur. Par exemple, define purge, setname
supprimerait toutes les définitions de l'ensemble nommé.
Tableaux, tableaux condensés et manipulation de texte
Les outils originaux de TUTOR pour la manipulation de texte étaient basés sur des commandes pour des opérations de texte spécifiques, par exemple, pack
pour placer une chaîne de caractères compressée dans des variables consécutives en mémoire, search
pour rechercher une chaîne dans une autre et move
pour déplacer une chaîne de mémoire en mémoire. En 1975, des outils plus généraux pour les tableaux d'entiers et les tableaux condensés ont été ajoutés. La page 14 de PLATO User's Memo -- Summary of TUTOR Commands and System Variables , Avner, 1975, donne ce qui suit :
define segment, name=starting var, num bits per byte, s
array, name(size)=starting var
array, name (num rows, num columns)=starting var
Les tableaux segmentés , définis avec le mot segment
- clé , étaient comparables aux tableaux compactés en Pascal . La taille en octets et si oui ou non les éléments du tableau devaient être traités comme signés ou non signés étaient entièrement sous le contrôle de l'utilisateur. Manipulation de texte arbitraire pourrait être fait en réglant la taille des octets à la taille de l' octet de la machine, 6 bits sur les mises en œuvre en utilisant le code d'affichage , 8 bits sur certains plus tard ASCII et ASCII étendus implémentations. Notez l'absence de toute spécification de dimensionnalité des tableaux pour les tableaux segmentés.
Passage de paramètres
Un mécanisme général de transmission de paramètres a été ajouté à TUTOR au début de l'ère PLATO IV. La page IV-10 de The TUTOR Language de Sherwood, 1974 donne l'exemple suivant :
define radius=v1,x=v2,y=v3
unit vary
do halfcirc(100,150,300)
do halfcirc(50)
*
unit halfcirc(radius, x,y)
circle radius, x,y,0,180
draw x-radius, y;x+radius, y
Notez que les paramètres formels répertoriés dans la liste d'arguments de la unit
commande sont simplement les noms définis pour les variables globales allouées statiquement. La sémantique du passage des paramètres a été donnée comme étant équivalente à l'affectation au moment du transfert de contrôle à l'unité de destination, et si les paramètres réels étaient omis, comme dans la deuxième do
commande ci-dessus, l'effet était de laisser les valeurs antérieures du formel correspondant. paramètres inchangés.
Variables locales
Les variables locales ont été ajoutées à TUTOR vers 1980. Les auteurs de leçons souhaitant utiliser des variables locales devaient utiliser la lvars
commande pour déclarer la taille du tampon utilisé pour les variables locales, jusqu'à 128 mots. Cela fait, une unité utilisant des variables locales pourrait commencer comme suit (à partir de la page C2 du résumé des commandes TUTOR et des variables système , Avner, 1981) :
unit someu
NAME1,NAME2,NAME3(SIZE)
NAME4=CONSTANT
floating:NAME5,NAME6,NAME7(SIZE)
integer, NUM BITS:NAME8,NAME9
integer, NUM BITS,signed:NAME10
integer:NAME11
Les lignes de continuation de la unit
commande donnée ci-dessus sont considérées comme des lignes d'une define
commande implicite avec une portée locale . Les définitions conventionnelles en termes de variables d'étudiant telles que celles qui n150
pourraient être utilisées dans un tel local define
, mais les formes illustrées ici lient toutes automatiquement les noms à des emplacements dans le bloc de mémoire alloué par la lvars
commande. La documentation TUTOR disponible n'explique pas comment les variables locales sont allouées.
Autres implémentations
Il existe une grande famille de langages liés à TUTOR, chacun similaire au langage TUTOR d'origine mais avec des différences. En particulier, TUTOR était un composant d'un système (le système d'éducation informatisé PLATO) qui fonctionnait sur un matériel central CDC particulier. Pour plus d'efficacité, il y avait des éléments spécifiques au matériel dans TUTOR (par exemple des variables qui étaient des mots de 60 bits qui pouvaient être utilisés comme des tableaux de 60 bits ou comme 10 caractères de six bits, etc.). De plus, TUTOR a été conçu avant l'avènement de l'interface utilisateur graphique (GUI) orientée Windows.
Le langage microTutor a été développé dans le projet PLATO à l'UIUC pour permettre à des parties d'une leçon de s'exécuter dans des terminaux contenant des micro-ordinateurs, avec des connexions au code TUTOR s'exécutant sur l'ordinateur central. Le dialecte microTutor était également le langage de programmation du système Cluster développé à l'UIUC et licencié à TDK au Japon ; le système Cluster consistait en un petit groupe de terminaux reliés à un mini-ordinateur qui assurait le stockage et la compilation. Le Tencore Language Authoring System est un dérivé de TUTOR développé par Paul Tenczar pour PC et vendu par Computer Teaching Corporation. cT était un dérivé de TUTOR et microTutor développé à Carnegie Mellon qui permettait aux programmes de s'exécuter sans changement dans les environnements GUI fenêtrés sur les systèmes Windows, Mac et Unix/Linux : Les archives du langage de programmation cT
Les références
Liens externes
- Guide de l'utilisateur PLATO , CDC Corporation, révisé en avril 1981.
- Mémo de l'utilisateur TUTOR. Introduction to TUTOR , Computer-Based Education Research Laboratory, Université de l'Illinois à Urbana Champaign, mars 1973.
- Mémo de l'utilisateur PLATO, numéro un : Résumé des commandes TUTOR et des variables système. Troisième édition , par Elaine Avner, Computer-Based Education Research Laboratory, Université de l'Illinois à Urbana Champaign, novembre 1975.
- Summary of TUTOR Commands and System Variables (10e édition) , par Elaine Avner, Computer-Based Education Research Laboratory, Université de l'Illinois à Urbana Champaign, novembre 1981.
- Une évaluation personnelle du système PLATO par Stewart A. Denenberg, ACM SIGCUE Outlook, 12, 2 (avril 1978) pages 3-10.
- Support d'exécution pour le langage TUTOR sur un petit système informatique , par Douglas W. Jones , 1976.
- The TUTOR Language , par Bruce Sherwood, Computer-Based Education Research Laboratory, Université de l'Illinois à Urbana Champaign, juin 1974.
- Le langage TUTOR , par Bruce Sherwood, Control Data Education Company, 1977.
- Le terminal étudiant Platon IV , par Jack Stifle
- Le langage de programmation cT (dérivé de TUTOR) du Center for Design of Educational Computing de l'Université Carnegie Mellon, par David Andersen, Bruce Sherwood, Judith Sherwood et Kevin Whitley (plus pris en charge depuis 2002).