HANDLEDARE

Den här artikeln handlar om programmeringsspråket. För typ av lärare, se Handledare . För annan användning, se Tutor (disambiguation) .
HANDLEDARE
Paradigm imperativ ( procedurmässig )
Designad av Paul Tenczar & Richard Blomme
Utvecklare Paul Tenczar & University of Illinois i Urbana-Champaign
Dök först upp 1969 ( 1969 )
Maskinskrivningsdisciplin ingen
Stora implementeringar
TUTOR, Micro-TUTOR
Influerad
TenCORE, USE ( Regency Systems )

TUTOR , även känt som PLATO Author Language , är ett programmeringsspråk utvecklat för användning i PLATO-systemet vid University of Illinois i Urbana-Champaign med början ungefär 1965. TUTOR designades ursprungligen av Paul Tenczar för användning i datorstödd instruktion (CAI) och datorstyrd instruktion (CMI) (i datorprogram som kallas "lektioner") och har många funktioner för det ändamålet. Till exempel har TUTOR kraftfulla kommandon för svarsanalys och svarsbedömning, grafik och funktioner för att förenkla hanteringen av studentposter och statistik för instruktörer. TUTOR:s flexibilitet, i kombination med PLATOs beräkningskraft (som kördes på vad som ansågs vara en superdator 1972), gjorde den också lämplig för att skapa spel — inklusive flygsimulatorer, krigsspel, flerspelarrollspel i fängelsehålsstil, kortspel, ord spel och medicinska lektionsspel som Bugs and Drugs ( BND ). TUTOR lever vidare idag som programmeringsspråk för Cyber1 PLATO System, som kör det mesta av källkoden från 1980-talets PLATO och har ungefär 5000 användare i juni 2020.

Ursprung och utveckling

TUTOR utvecklades ursprungligen som ett författarspråk för speciella syften för att utforma instruktionslektioner, och dess utveckling till ett allmänt programmeringsspråk var oplanerad. Namnet TUTOR applicerades först på författarspråket i PLATO-systemet under Platon III:s senare dagar. Den första dokumentationen av språket, under detta namn, verkar ha varit The TUTOR Manual , CERL Report X-4, av RA Avner och P. Tenczar, januari 1969.

Artikeln Teaching the Translation of Russian by Computer ger en ögonblicksbild av TUTOR från kort innan PLATO IV var i drift. Kärnelementen i språket var närvarande, men kommandon gavs med versaler, och istället för att använda en allmän mekanism, stöddes alternativa teckenuppsättningar genom speciella kommandonamn som WRUSS för "skriva med den ryska teckenuppsättningen . "

Under 1970-talet utnyttjade utvecklarna av TUTOR det faktum att hela korpusen av TUTOR-program lagrades online på samma datorsystem. Närhelst de kände ett behov av att ändra språket körde de konverteringsprogram över korpusen av TUTOR-kod för att revidera all befintlig kod så att den överensstämde med de ändringar de hade gjort. Som ett resultat, när nya versioner av TUTOR väl utvecklats, kan det vara mycket svårt att upprätthålla kompatibiliteten med PLATO-versionen.

Control Data Corporation (CDC), 1981, hade i stort sett tagit bort namnet TUTOR från deras PLATO-dokumentation. De hänvisade till själva språket som PLATO Author Language . Frasen TUTOR-fil eller till och med TUTOR-lektionsfil överlevde dock som namnet på den typ av fil som används för att lagra text skriven på PLATO Author Language.

Struktur för en TUTOR-lektion

En TUTOR-lektion består av en sekvens av enheter där varje enhet börjar med presentation av information och framsteg från en enhet till nästa är beroende av att en eller flera frågor besvaras korrekt. Precis som med COBOL- stycken kan kontrollen komma in i en TUTOR-enhet från den föregående enheten och gå ut i nästa, men enheter kan också anropas som subrutiner med hjälp av kommandona do eller join .

Här är ett exempel från sidan 5 i TUTOR User's Memo , mars 1973 ( Computer-based Education Research Laboratory , University of Illinois i Urbana-Champaign): 

enhet matematik vid 205 skriv Svara på dessa uppgifter 3 + 3 = 4 × 3 = pil 413 svar 6 pil 613 svar 12

Flera saker bör omedelbart framgå av detta exempel.

  • För det första är TUTOR ett språk med fast format. Varje rad börjar med ett kommandonamn, som måste rymmas inom ett fast 8-teckensfält för kommandonamnet. Argumenten till det kommandot (taggen ) börjar med det nionde tecknet. Även om en tabbnyckel användes för att komma till den nionde kolumnen, genererade den mellanslag eftersom platon inte hade något tabbtecken.
  • I vissa fall, som skrivkommandot ovan , kan taggen bestå av flera rader. Fortsättningsrader är antingen tomma eller har en inledande flik.
  • Skärmkoordinater presenteras som enstaka siffror, så 205 hänvisar till rad 2 kolumn 5 och 413 hänvisar till rad 4 kolumn 13.

Vad som kanske inte är uppenbart är kontrollstrukturen implicit i denna enhet. Pilkommandot markerar ingången till ett bedömningsblock. Denna kontrollstruktur är en av TUTOR:s unika egenskaper .

Unika funktioner

TUTOR innehöll ett antal unika funktioner. Följande lista är inte avsedd som en ersättning för en TUTOR-manual, utan lyfter bara fram de mest intressanta, innovativa och ibland förvirrande funktionerna i språket.

Svar att döma

Ett bedömningsblock i TUTOR är en kontrollstruktur som börjar med ett pilkommando och slutar med nästa pil , endarrow eller enhetskommando . Pilkommandot uppmanar också till inmatning, med det speciella piltecknet (som liknar "▷") visas som en uppmaning vid de angivna skärmkoordinaterna . I själva verket kan ett bedömningsblock ses som en bakåtgående kontrollstruktur där eleven kan göra flera försök att svara på en fråga tills ett korrekt svar tillåter framsteg framåt.

Bedöma mönstermatchning

Varje bedömningsblock består av en sekvens av mönstermatchningskommandon , som vart och ett introducerar ett (eventuellt tomt) block av kommandon som ska utföras om mönstret matchar. De två vanligaste mönstermatchningskommandona var svar och fel . Dessa hade identisk mönstermatchningssemantik förutom att svaret bedömde ett elevsvar som korrekt om det matchade, medan fel bedömde ett elevsvar som felaktigt.

Taggfälten på svaret och fel kommandon bestod av listor med valfria, obligatoriska och alternativa ord. betrakta detta exempel från övning 4-1 i 1973 TUTOR User's Memo : 

svar (höger, rt) (triangel, triangulär)

Detta skulle matcha svar som "det är en rätvinklig triangel" eller "det är en triangulär figur" eller bara "rt triangel". Det skulle inte matcha "typ av triangulär" eftersom orden "typ av" inte är listade som ignorerade, och det skulle inte matcha "triangel, eller hur?" eftersom ordningen är fel.

Mönstermatchningsundersystemet kände igen stavfel, så orden "triangel" eller "triangel" skulle matcha exempelmönstret. Lektionsförfattaren kunde använda specs för att ställa in hur pedantisk systemet var med stavfel.

De mönstermatchningsalgoritmer som användes av olika TUTOR-implementeringar varierade i detalj, men vanligtvis konverterades varje ord i inmatningstexten och varje ord i mönstret till bitvektorer . För att se om ett ord av elevinmatning matchade ett ord i mönstret, Hamming-avståndet mellan de två bitvektorerna som ett mått på graden av skillnad mellan orden. Bitvektorer var vanligtvis 60 eller 64 bitar långa, med fält för bokstavsnärvaro, bokstavsparnärvaro och den första bokstaven. Som ett resultat approximerade antalet en bit i de exklusiva eller två sådana bitvektorer omfattningen av den fonetiska skillnaden mellan de motsvarande orden.

Bedömning av kontrollstrukturer

Alla tidiga presentationer av kontrollstrukturen för ett TUTOR-bedömningsblock var förvirrande. I moderna termer kan dock ett bedömningsblock beskrivas som en iterativ kontrollstruktur som upphör när elevinmatningen bedöms vara korrekt. Huvuddelen av denna kontrollstruktur består av en serie fall , vart och ett introducerat av ett mönstermatchningskommando som svar eller fel . All utmatning som produceras av kroppen av bedömningsslingan i föregående cykel raderas från skärmen före nästa cykel.

Betrakta det här exemplet, från övning 4-1 i 1973 TUTOR User's Memo : 

fel kvadrat vid 1501 skriv En kvadrat har fyra sidor.

I händelse av att eleven matar in "kvadrat" eller "en kvadrat", bedöms svaret vara felaktigt, och texten "En ruta har fyra sidor." matas ut från rad 15 kolumn 1 på skärmen. Denna utdata finns kvar på skärmen tills eleven börjar skriva in ett nytt svar, vid vilken tidpunkt den raderas så att svaret på det nya svaret kan beräknas. Mekanismen med vilken bildskärmen rullar tillbaka till sitt tidigare tillstånd varierar från implementering till implementering. Tidiga implementeringar fungerade genom att växla terminalen till raderingsläge och köra om hela fallet som hade matchat. Några senare implementeringar buffrade utdata som producerades under bedömning så att denna utdata kunde raderas.

Kommandot join var en unik form av subrutinsamtal. Det definierades som likvärdigt med textersättning av den sammanfogade enhetens kropp i stället för själva join-kommandot (sida 21, 1973 TUTOR User's Memo ). Som sådan kan en sammanfogad enhet innehålla en del av ett bedömningsblock. Sålunda, medan bedömningsblocket begreppsmässigt är en iterator som omsluter en serie fall , kan detta block godtyckligt delas upp i subrutiner. (Ett alternativt subrutinsamtal, kommandot do , överensstämde med den vanliga semantiken som är associerad med subrutinanrop på andra programmeringsspråk.)

Grafik- och displaykommandon

PLATO IV-studentterminalen hade en plasmaskärm med 512 x 512 pixlar , med hårdvarustöd för punktplottning , linjeritning och textvisning. Varje pixel på PLATO IV-terminalen var antingen orange eller svart. CDC PLATO V-terminalen använde en monokrom svartvit CRT för att emulera plasmapanelen. Den inbyggda teckenuppsättningen hade 4 uppsättningar med 63 tecken, vardera 8 gånger 16 pixlar, hälften av dessa var fasta, hälften var programmerbara. Tutor-språket gav komplett stöd för denna terminal.

Det fanns två koordinatsystem (se sidan II-1 i The TUTOR Language av Bruce Sherwood):

  • Grova koordinater specificerades i termer av textrader och kolumner. Den grova koordinaten 1501 var till exempel en referens till rad 15 tecken 1, där det övre vänstra tecknet på skärmen var på plats 101 och det nedre högra tecknet var på 3264.
  • Fina koordinater specificerades som X- och Y-koordinater i förhållande till det nedre vänstra hörnet av skärmen. Den fina koordinaten 0,511 specificerade skärmens övre vänstra hörn, medan 0,496 var ekvivalent med den grova 101, vilket medger höjden på 16 pixlar för ett tecken och det faktum att tecken plottades i förhållande till deras nedre vänstra hörn.

Ritkommandon

Följande exempel illustrerar några av handledarens ritkommandon.

rita 1812;1852;hoppa;1844;1544 cirkel 16.344.288 rita 1837;1537;1535;1633;1833

Notera användningen av semikolon för att separera successiva koordinater på ritkommandot . Detta tillåter entydig användning av kommaseparerade fina koordinater. Normalt kopplar ritkommandot på varandra följande punkter med linjesegment, men genom att sätta skip i taggen kan ritkommandot fås att konceptuellt lyfta pennan.

Taggarna på cirkelkommandot anger radie och fina koordinater för mitten. Ytterligare taggar kan ange start- och slutvinklar för delcirklar.

Att för hand komponera ritkommandon är svårt, så en bildredigerare inkluderades i PLATO-systemet 1974 för att automatisera detta arbete. Detta kunde bara hantera ritkommandon med konstanta koordinater.

Kommandon för textåtergivning

Följande exempel illustrerar några av Tutors verktyg för textåtergivning.

enhetstitelstorlek 9,5 $$ text 9,5 gånger normal storlek rotera 45 $$ text roterad 45 grader vid 2519 skriv latinsk storlek 0 $$ återgå till normal skrift rotera 0 vid 3125 skriv Lektioner om verb

Text renderad i storlek noll rotation noll använde den inbyggda teckenåtergivningshårdvaran i PLATO-terminalen, medan rendering med icke-nollstorlek och rotation gjordes med linjesegment och därför betydligt långsammare på grund av hastigheten på kommunikationslänken till terminalen.

Kontrollstrukturer

Bortsett från dess unika svarsbedömningsmekanismer var TUTORs ursprungliga uppsättning kontrollstrukturer ganska sparsam. I mitten av 1970-talet åtgärdades denna brist genom att introducera if , endif- block med valfria elseif och else -sektioner. Semantiken för dessa kontrollstrukturer var rutinmässig, men syntaxen ärvde den obligatoriska indragningen av Tutor Language, förutskick den för Python och lade till ett unikt icke-tomt indragstecken för att skilja indrag från fortsättningsrader.

Detta illustreras i följande exempel, från sidan S5 i sammanfattningen av TUTOR-kommandon och systemvariabler (10:e upplagan) av Elaine Avner , 1981: 

om n8<4 . skriv första grenen. beräkna n9⇐34 annat om n8=4 . skriv andra grenen. göra någonting annat. skriv standardgren . om n8>6. . skriv specialgren . endif endif

( Tilldelningspilen i calc -satsen återges inte korrekt i vissa webbläsare. Den ser ut som <= men som ett tecken. Den hade en dedikerad tangent på PLATO IV-tangentbordet.)

Samma syntax användes för loop , endloop- block med semantik jämförbar med while-loopar i konventionella programmeringsspråk. Detta illustreras i följande exempel, från sidan S6 i sammanfattningen av TUTOR-kommandon och systemvariabler (10:e upplagan) av Elaine Avner, 1981: 

slinga n8<10 . skriv inom loop . sub1 n8 reloop n8≥5 . skriv fortfarande inom loop . gör någon enhet outloop n8<3 . skriv fortfarande inom loop endloop skriv utanför loop

Observera att reloop- och outloop -kommandona är något analoga med continu- och break -satserna för språk baserade på C , förutom att de måste sitta på indragsnivån för slingan de modifierar, och de har en villkorstagg som indikerar när den indikerade kontrollen överförs ska ske. Detta gör konstruktionen mer kraftfull än på andra språk, eftersom vilken linje som helst i den inre slingan kan avsluta eller återgå flera yttre slingor med en sats.

Uttryckssyntax

TUTORs uttryckssyntax såg inte tillbaka till syntaxen för FORTRAN , och den var inte heller begränsad av dåligt utformade teckenuppsättningar från eran. Till exempel inkluderade PLATO IV-teckenuppsättningen kontrolltecken för nedsänkt och upphöjd , och TUTOR använde dessa för exponentiering. Tänk på det här kommandot (från sidan IV-1 i The TUTOR Language , Sherwood, 1974): 

 cirkel (41  2  +72,6  2  )  1/2  ,100,200

Teckenuppsättningen inkluderade också de konventionella symbolerna för multiplikation och division, × och ÷ , men i en mer radikal avvikelse från de konventioner som fastställts av FORTRAN, tillät den implicit multiplikation, så uttrycken ( 4+7)(3+6) och 3.4 +5(2 3 -3)/2 var giltiga, med värdena 99 respektive 15,9 (op cit). Denna funktion ansågs vara väsentlig. När eleverna skrev in ett numeriskt svar på en fråga kunde de använda operatorer och variabler och standardalgebraisk notation, och programmet skulle använda kommandot TUTOR "compute" för att kompilera och köra formeln och kontrollera att den var numeriskt ekvivalent (eller inom flyttalsavrundningsfel) till rätt svar.

Språket inkluderade en fördefinierad konstant namngiven med den grekiska bokstaven pi (π), med lämpligt värde, som kunde användas i beräkningar. Således skulle uttrycket πr 2 kunna användas för att beräkna arean av en cirkel, med hjälp av den inbyggda π-konstanten, implicit multiplikation och exponentiering indikerad med en upphöjd skrift.

I TUTOR definierades flyttalsjämförelsen x=y som sann om x och y var ungefär lika (se sidan C5 i PLATO User's Memo, Number One av Avner, 1975). Detta förenklade livet för matematiskt naiva utvecklare av instruktionslektioner, men det orsakade ibland huvudvärk för utvecklare av numeriskt sofistikerad kod eftersom det var möjligt att både x<y och x≥y kunde vara sanna samtidigt.

Minneshantering

Som ett författarspråk började TUTOR med endast minimala minnesresurser och bara de grövsta verktygen för att manipulera dem. Varje användarprocess hade ett privat datasegment med 150 variabler och delade gemensamma block kunde kopplas, vilket möjliggör kommunikation mellan användare genom delat minne.

På PLATO IV-systemet var orden 60 bitar, i linje med CDC 6600- familjen av datorer. Vissa senare implementeringar ändrade detta till 64 bitar.

Grundläggande minnesresurser

Den privata minnesregionen för varje process bestod av 150 ord vardera, kallade elevvariabler; värdena för dessa variabler var beständiga och följde den individuella användaren från session till session. Dessa adresserades som n1 till n150 när de användes för att hålla heltalsvärden, eller som v1 till v150 när de användes för att hålla flyttalsvärden.

En TUTOR-lektion kan bifoga en enskild region med upp till 1500 ord delat minne med det gemensamma kommandot. Varje lektion kan ha ett icke namngivet temporärt gemensamt block som innehåller variabler som delas av alla användare av den lektionen. Sådana block skapades när en lektion togs i bruk och omallokerades när lektionen blev inaktiv. Däremot var namngivna vanliga block associerade med ett block av en lektion (en diskfil). Delat minne adresserades som ncl till nc1500 (för heltal) eller vcl till vc1500 (för flyttal).

Där 150 elevvariabler var otillräckliga kunde en lektion använda lagringskommandot för att skapa ytterligare ett privat minnessegment på upp till 1000 ord. Detta segment fanns endast i swap-utrymme, men det kunde mappas till elevvariabler eller vanliga variabler. Till exempel (från sida X-11 i The TUTOR Language , Sherwood, 1974): 

gemensam 1000 lagring 75 stoload vc1001,1,75

Det här exemplet definierar nc1 till nc1000 som ett delat namnlöst gemensamt block, medan nc1001 till nc1075 är privat lagring.

Definiera symboliska namn

Tutor define var mycket likt C #define preprocessor- direktivet. Detta var det enda sättet att associera mnemoniska namn med variabler. Det var upp till programmeraren att statiskt allokera minne och tilldela namn till variabler. Betrakta det här exemplet från sidan 17 i TUTOR User's Memo -- Introduction to TUTOR , 1973" 

definiera mina namn först=v1, andra =v2 resultat=v3

Detta skapar en uppsättning definitioner som heter mynames som definierar tre flyttalsvariabler. Användare informerades om att " det inte borde finnas några v3 eller v26 någonstans i din lektion förutom i själva define -satsen . Sätt alla dina definitioner i början av lektionen där du kommer att ha en referens till vilka variabler du använder." (understrykning från originalet, sida IV-5 i The TUTOR Language , Sherwood, 1974.)

Funktioner kan definieras, med makro-substitution semantik, som i denna illustration från sidan IX-2 i The TUTOR Language , Sherwood, 1974: 

definiera cotan(a)=cos(a)/sin(a)

Till skillnad från C var TUTORs ursprungliga räckviddsregler ren "definition före användning" utan bestämmelser för lokala definitioner. Den formella parametern som används ovan får alltså inte ha någon tidigare definition.

Senare i utvecklingen av TUTOR, med introduktionen av flera namngivna definitionsuppsättningar, fick programmeraren explicit kontroll över vilka uppsättningar av definitioner som för närvarande var i kraft. Definiera till exempel rensa, setname skulle kassera alla definitioner i den namngivna uppsättningen.

Arrayer, packade arrayer och textmanipulation

De ursprungliga TUTOR-verktygen för textmanipulering baserades på kommandon för specifika textoperationer, till exempel packa för att placera en packad teckensträng i på varandra följande variabler i minnet, sök för att söka efter en sträng i en annan och flytta för att flytta en sträng från minnet till minne. År 1975 lades mer allmänna verktyg för arrayer av heltal och packade arrayer till. Sida 14 i PLATO User's Memo -- Sammanfattning av TUTOR-kommandon och systemvariabler , Avner, 1975, ger följande: 

definiera segment, namn=start var, antal bitar per byte, s array, namn(storlek)=start var array, namn (antal rader, antal kolumner)=start var

Segmenterade arrayer , definierade med nyckelordssegmentet , var jämförbara med packade arrayer i Pascal . Bytestorleken och huruvida arrayelementen skulle behandlas som signerade eller osignerade var helt under användarkontroll. Godtycklig textmanipulering kan göras genom att ställa in bytestorleken till maskinbytestorleken, 6 bitar på implementeringar med visningskod , 8 bitar på några senare ASCII- och utökade ASCII- implementationer. Notera avsaknaden av någon specifikation av arraydimensionalitet för segmenterade arrayer.

Parameter passerar

En generell parameteröverföringsmekanism lades till TUTOR tidigt på PLATO IV-eran. Sida IV-10 i The TUTOR Language av Sherwood, 1974 ger följande exempel: 

definiera radie=v1,x=v2,y=v3 enhet variera do halfcirc(100,150,300) do halfcirc(50) * enhet halfcirc(radie, x,y) cirkelradie, x,y,0,180 rita x-radie, y;x +radie, y

Lägg märke till att de formella parametrarna som listas i argumentlistan till enhetskommandot helt enkelt är de definierade namnen för statiskt allokerade globala variabler. Semantiken för parameterpassering angavs som likvärdig med tilldelning vid tidpunkten för kontrollöverföringen till destinationsenheten, och om faktiska parametrar utelämnades, som i det andra do- kommandot ovan, var effekten att de tidigare värdena för motsvarande formella parametrar oförändrade.

Lokala variabler

Lokala variabler lades till TUTOR någon gång runt 1980. Lektionsförfattare som ville använda lokala variabler var tvungna att använda kommandot lvars för att deklarera storleken på bufferten som används för lokala variabler, upp till 128 ord. Efter att ha gjort det kan en enhet som använder lokala variabler börja enligt följande (från sida C2 i Sammanfattning av TUTOR-kommandon och systemvariabler, Avner, 1981): 

enhet något NAMN1,NAMN2,NAMN3(STORLEK) NAMN4=KONSTANT flytande:NAMN5,NAMN6,NAMN7(STORLEK) heltal, NUM BITS:NAMN8,NAMN9 heltal, NUM BITS,signerad:NAMN10 heltal:NAMN11

Fortsättningsraderna för enhetskommandot ovan anses vara rader av ett implicit definiera kommando med lokalt omfång . Konventionella definitioner i termer av studentvariabler som t.ex. n150 skulle kunna användas i en sådan lokal define , men formerna som illustreras här binder alla automatiskt namn till platser i minnesblocket som tilldelats av kommandot lvars . Den tillgängliga TUTOR-dokumentationen diskuterar inte hur lokala variabler allokeras.

Andra implementeringar

Det har funnits en ansenlig familj av TUTOR-relaterade språk, alla liknar det ursprungliga TUTOR-språket men med skillnader. I synnerhet var TUTOR en komponent i ett system (PLATOs datorbaserade utbildningssystem) som kördes på speciell CDC stordatorhårdvara. För effektivitetens skull fanns det några hårdvaruspecifika element i TUTOR (t.ex. variabler som var 60-bitars ord som kunde användas som arrayer med 60 bitar eller som 10 sexbitars tecken, etc.). Dessutom designades TUTOR före tillkomsten av det Windows-orienterade grafiska användargränssnittet (GUI).

MicroTutor-språket utvecklades i PLATO-projektet vid UIUC för att tillåta delar av en lektion att köras i terminaler som innehöll mikrodatorer, med anslutningar till TUTOR-kod som körs på stordatorn. MicroTutor-dialekten var också programmeringsspråket för Cluster-systemet som utvecklats vid UIUC och licensierat till TDK i Japan; Cluster-systemet bestod av en liten grupp terminaler kopplade till en minidator som gav lagring och kompilering. Tencore Language Authoring System är ett TUTOR-derivat utvecklat av Paul Tenczar för PC och säljs av Computer Teaching Corporation. cT var ett derivat av TUTOR och microTutor utvecklade på Carnegie Mellon som gjorde det möjligt för program att köras utan förändring i fönsterbaserade GUI-miljöer på Windows, Mac och Unix/Linux-system.

externa länkar


Hämtad från " https://en.wikipedia.org/w/index.php?title=TUTOR&oldid=1070873187 "