| Clu | |
|---|---|
| Sprog klasse | Objektorienteret , proceduremæssig |
| Udførelsestype | Kompileret |
| Dukkede op i | 1974 |
| Forfatter | Barbara Liskov |
| Udvikler | Barbara Liskov og MIT |
| Filtypenavn _ | .clu |
| Type system |
streng , statisk |
| Større implementeringer | Bærbar Clu, NativeCLU, Klu-Elbrus, clu2c |
| Blev påvirket | Simula , Lisp , Pascal |
| påvirket | Ada , C++ , Java , Sather , Lua |
| Internet side | pmg.lcs.mit.edu/CLU.html |
Clu ( engelsk Clu , CLU ) er et objektorienteret programmeringssprog , et af de første til at implementere konceptet med abstrakte datatyper og det generiske programmeringsparadigme . Oprettet af en gruppe forskere ved Massachusetts Institute of Technology under ledelse af Barbara Liskov i 1974, har den ikke fundet bred anvendelse i praksis, men mange af dens elementer er blevet brugt til at skabe sprog som Ada , C++ , Java , Sather , Python , C# .
Systematisk arbejde med skabelsen af et programmeringssprog, der implementerer ideerne om dataabstraktion på syntaktisk niveau, begyndte i foråret 1973 af Barbara Liskov og en ansat i IBMs forskningslaboratorium, Steve Zilles . I september 1973 blev deres fælles notat [1] offentliggjort , som beskriver en foreløbig version af et sådant Pascal-lignende sprog, det indeholder et sådant særpræg ved det fremtidige sprog som klynger ; baseret på denne note blev der udarbejdet en rapport på SIGPLAN konferencen om sprog på superhøjt niveau i 1974 [2] . Ved udgangen af 1973 havde Liskov og Zilles allerede besluttet sig for navnet på det fremtidige sprog: navnet "Clu" blev valgt blandt de første tre bogstaver i det engelske ord cluster [3] . Austin Henderson var involveret som modstander .
I december 1973, i datalogilaboratoriet ved Massachusetts Institute of Technology, med støtte fra National Science Foundation og DARPA , begyndte arbejdet med skabelsen af et sprog, Liskov ledede gruppen, Zilles arbejdede aktivt på sproget i den indledende trin arbejdede tre kandidatstuderende løbende i gruppen - Russ Atkinson ( Russ Atkinson ), Craig Shaffert ( Craig Schaffert ) og Alan Snyder ( Alan Snyder ), studerende og ansatte på instituttet var også periodisk knyttet til arbejdet. Alt arbejde blev udført på PDP-10 maskiner .
Liskov identificerede 7 nøgleprincipper i sproget: et strengt fokus på dataabstraktion (afvisning af dyb undersøgelse af funktioner, der ikke er direkte relateret til dataabstraktion), minimalisme, enkelhed, udtryksfuldhed af midler, forening (indbyggede typer bør ikke adskille sig fra programmør- definerede typer), sikkerhed og høj ydeevne [4] . I overensstemmelse med disse principper vælges løsninger som afvisning af opregnede typer , parallel tildeling , statisk typning , kompileringstidstypekontrol, run-time skraldesamling i implementeringen . I 1974 blev den første compiler af sproget implementeret, og frigav kode i Lisp, senere blev compileren omskrevet til at generere programmer på Lisp-dialekten MDL , som havde et rigere sæt indbyggede datastrukturer og typekontrol på kompileringsstadiet. Den første implementering af sproget i 1974 blev kaldt CLU .5 , det understøttede de grundlæggende dataabstraktionskonstruktioner, men implementerede endnu ikke undtagelseshåndtering og iteratorer , og implementeringen af parameteriserede typer krævede dynamisk typekontrol i køretid. I 1975 blev undtagelseshåndteringsmekanismen grundlæggende designet.
I 1976 var alle nøgleelementerne i sproget implementeret, i 1977 blev den første compiler skrevet, der genererede kode i assembler . Compileren blev skabt i selve Clu-sproget, som skulle demonstrere sprogets udtryksevne. Opbygning af en compiler, der genererede højtydende programmer, krævede oprettelsen af et særligt runtime-miljø, der implementerede affaldsindsamling, fejlfinding, særlige undtagelseshåndteringsteknikker og iteratorunderstøttelse. I 1979 blev designet af sproget afsluttet [5] , i 1980 blev en fuldgyldig compiler til PDP-10 frigivet, og compilere til MC68000 og VAX blev implementeret noget senere . Arbejdsomkostninger for skabelsen af sproget anslås til 14 årsværk [6] .
I midten af 1980'erne blev Klu-kompilatoren implementeret til de sovjetiske Elbrus -supercomputere , sproget blev udvalgt blandt andre kandidater ( Ady , Moduly-2 , Simula ) som det mest holistisk inkorporerende begrebet abstrakte datatyper, samtidig med at det var ret simpelt at implementere [7] . I 1989 blev der udgivet en compiler til SPARC , der kører SunOS .
I begyndelsen af midten af 1990'erne blev clu2c-kompileren skabt, der genererede C -kode på tværs af platforme , samt flere versioner af Portable Clu med builds til Linux , NetBSD , Mac OS , Windows NT , Digital Unix (på Alpha ), men Den praktiske interesse for sproget faldt markant, og siden slutningen af 1990'erne er der faktisk ikke udviklet implementeringer, og ny software på Klu er ikke blevet udviklet.
Barbara Liskov vandt Turing-prisen i 2008 i nomineringen af at designe Clu-sproget og skabe en række effektive compilere til det, kendt som et grundlæggende bidrag til datalogi, der beviser den praktiske gennemførlighed af dataabstraktionsideer og gør et teoretisk koncept til et generelt anerkendt tilgang i programmeringsindustrien [8] .
En abstrakt datatype i Klu implementeres af konceptet om en klynge, en konstruktion, der giver indkapsling inden for typen af operationer på den og giver polymorfi (en klynge kan beskrive en bred klasse af datatyper med en fælles specifikation - det samme sæt af operationer, men anderledes implementering).
Det indledende fragment af beskrivelsen af en klynge af en polymorf liste (med operationer i Lisp-notation):
liste = klynge [t: type] er oprette, bil, cdr, ulemper, elems rep = array [t] oprette = proc () returnere ( cvt ) % liste oprettelse returnere ( rep$new ()) ende oprette ; car = proc ( l:cvt ) return ( t ) signaler ( tom ) % får det første element på listen hvis rep$empty ( l ) så signal tom else return ( rep$bottom ( l )) end end car ; % andre operationer afslutter listenKlyngedefinitionen specificerer specifikationen - et sæt operationer på typen, definerer den interne repræsentation ( rep) og beskriver implementeringen af operationerne. Konstruktioner som typekonvertering fra intern til objektrepræsentation og omvendt ( cvt), $-notation til at få adgang til typeoperationer bruges. Oprettelsen af en klyngeimplementering og dens instans implementeres ved at specificere en specifik type:
lint = liste [int] ; % liste over heltal l:lint := lint$create () ; % instansierer listen l := lint$cons ( 1 , lint$cons ( 2 , lint$cons ( 3 , l ))) % konstruer listenIndbyggede typer er også implementeret som klynger [9] . I modsætning til klynger defineret i programkoden, kan ingen handling på de grundlæggende indbyggede Clu-datatyper ( int, real, bool, null, char, string) ændre strukturen og værdien af objektet (hver gang en ny forekomst af objektet oprettes med den tilsvarende tilstand fast). Men i jagten på ensretning er adgang til operationer på indbyggede typer tilgængelig i klyngenotation: int$add(n1,n2)tilføjer n1med n2, giver string$fetch(s,i)adgang til istrengens -te karakter sog string$concat(s1,s2) sammenkæder strenge s1og s2desuden implementeres et syntaktisk sukker , der giver en forkortet notation for sådanne operationer: , , ) introduceret i klynger defineret af udvikleren. n1+n2s[i]s1||s2addfetchconcat
Som polymorfe klynger implementeres indbyggede sammensatte typer, kaldet "typegeneratorer" i Klu- arrays , sekvenser , poster , strukturer (konstante poster), fagforeninger , varianter [10] .
En af de vigtigste nyskabelser i sproget var indførelsen af en kontrolabstraktion - en iterator . Ideen med en iterator er at give en generisk implementering af adgang til elementerne i en abstrakt datatype, uanset dens parameterisering og interne struktur. Et eksempel på en polymorf listeiterator:
elems = iter ( l:cvt ) giver ( t ) for elt:t i rep$elementer ( l ) do yield ( elt ) end end elemsKalder en iterator som dette:
for i:int i lint$elems ( l ) gør skriveint ( i ) endeBrugen af en iterator eliminerer brugen af eksplicitte loop-tællere under forhold, hvor den specifikke implementering af datatypen ikke er kendt på forhånd.
Ideen om en coroutine iterator blev efterfølgende lånt fra Icon , Sather , Python , Ruby , C# (siden version 2.0 ) [11] .
Klu implementerer strukturel undtagelseshåndtering , undtagelser i sproget er opdelt i statiske og dynamiske, førstnævnte bruges til at fuldføre udførelsen af en blok inden for en enkelt programblok (kaldet af operatøren exit s(x1, …, xn)), sidstnævnte afslutter programafviklingen (kaldes af operatør signal s(x1, …, xn)). I begge tilfælde håndteres undtagelsen af en programblok, der begynder med nøgleordet except, hvis en statisk undtagelse ikke håndteres i den aktuelle blok, så sendes den videre til den næste; undtagelser, der ikke håndteres i programmet, afbryder dets eksekvering med udstedelse af passende meddelelser. De undtagelser, som en procedure kan give, er specificeret i dens specifikation, undtagelser betragtes som en alternativ udgang fra proceduren, dvs. proceduren skal overføre værdien, der er deklareret i specifikationen til outputtet ved hjælp af operatøren return, eller udstede en af undtagelserne erklæret i specifikationen ved hjælp af operatorerne signaleller resignal(kaldet i blokken exceptfor at gentage den, der forårsagede undtagelsen) med de relevante parametre. Indbyggede typer implementerer standardundtagelser.
Ved udformningen af undtagelsesmekanismen blev løsninger lånt fra PL/1 og Mesa , men undtagelsesgenoptagelsesmodellen, der blev brugt i dem, er blevet væsentligt forenklet og struktureret [12] , og muligheden for at videregive undtagelsesparametre er blevet en vigtig innovation.