Ohjelmointiparadigmojen historia

1. Ohjelmointiparadigmojen historia 10.5.2001 Tietojenkäsittelytieteen historia -seminaari Mikko Teräs

2. Ohjelmoinnin esihistoriaa • Ensimmäiset algoritmit Mesopotamiassa n. 2000 e.Kr. • Ohjelmointi 1800-luvulta alkaen • Korkean tason kielet 1945

3. Ohjelmointiparadigmoista • Ohjelmointiparadigmat liittyvät korkean tason ohjelmointiin • Kuvaavat kielissä käytettyä ajattelutapaa, idiomia, filosofiaa • Esim. imperatiiviset, funktionaaliset, deklaratiiiviset, olio-, rinnakkais- ja logiikkakielet

4. 1940-1960 • Ensimmäinen korkean tason kieli: Zusen Plankalkül, 1945 • Ensimmäinen yleisesti tunnettu kieli: Short Code, 1949 • Ensimmäinen kääntäjä: AUTOCODE, 1952 • 1945-1957 tutkittiin n. 20 korkean tason kieltä, pääasiassa imperatiivisia

5. Fortran • 1950-luvulla vain konekieltä pidettiin riittävän tehokaana, vaikka se ymmärrettiin hankalaksi ja siirtokelvottomaksi • Fortranin tarkoituksena oli tuottaa yhtä tehokasta koodia kuin hyvä konekieliohjelmoija • Ensimmäinen toteutus 1957

6. “Object programs produced by Fortran will be nearly as efficient as those written by good programmers.” • Saavutti heti huomattavan suosion.

7. int i; float y; float a[11]; float f (float t) { return sqrt(fabs(t)) + 5 * t * t * t; } int main (void) { for (i = 0; i <= 10; ++i) scanf(“%d”, a[i]); for (i = 10; i >= 0; --i) { y = f(a[i]); if (y > 400) printf(“%d TOO LARGE\n”, i); else printf(“%d %d\n”, i, y); return 0; } TPK-algoritmi, C

8. DIMENSION A(11) READ A 2 DO 3, 8, 11 J = 1, 11 3 I = 11 - J Y = SQRT(ABS(A(I+1))) + 5 * A(I + 1)**3 IF (400 >= Y) 8, 4 4 PRINT I, 999. GO TO 2 8 PRINT I, Y 11 STOP TPK-algoritmi, Fortran 0

9. FUNF(T) = SQRTF(ABSF(T)) +5.0*T**3 DIMENSION A(11) FORMAT(6F12.4) 1 READ 1, A DO 10 J = 1,11 I = 11 - J Y = FUNF(A(I+1)) IF (400.0-Y) 4, 8, 8 4 PRINT 5, I 5 FORMAT(I10, 10H TOO LARGE) GO TO 10 PRINT 9, I, Y 9 FORMAT(I10, F12.7) 10 CONTINUE STOP 52525 TPK-algoritmi, Fortran 1

10. LISP 1956-1959 • Listakieli tekoälyohjelmointiin • Fortranin listalaajennus FLPL • LISP 1 1958: rekursio, ehtolausekkeet, roskienkeruu... • LISP 1.5 1959: paranteluja, erityisesti laskennassa

11. 1960-luku: ALGOL • ALGOL 60 uudisti imperatiiviset kielet esittelemällä lohkorakenteen • “ALGOLin kaltaiset kielet” • Käytettiin laajasti yliopistomaailmassa ja julkaisuissa, ei menestystä teollisuudessa • ALGOL 68: komitean suunnittelema hevonen

12. procedure TPK (a[]) =: b[]; array (a[0:10], b[0:21]); begin for i := 10(-1)0; begin y := f(a[i]); f(t) := sqrt(abs(t)) + 5× t  3 ; if (y > 400); y := 999; b[20 - 2 × i] := i; b[21 - 2 × i] := y end; return; integer (i) end TPK TPK-algoritmi, ALGOL 60

13. 1960 ja ohjelmistokriisi • 1960-luvulla jouduttiin etsimään uusia tapoja tuottaa oikein toimivia ohjelmia • Matalan tason rakenteet joutuivat kritiikin kohteeksi • Yrityisesti goto-lause puhutti: goto:ttomia kokeiluja jo vuonna 1960

14. Ohjelmistokriisi... • Dijkstra: Go To Statement Considered Harmful • “For a number of years I have been familiar with the observation that the quality of programmers is a decreasing function of the density of go to statements in the programs they produce.”

15. Kokeilut jatkuivat: • “It is my aim to write programs with no labels. I am doing quite well. I have got the operating system down to 5 labels and I am planning to write a compiler with no labels at all.” -- Christopher Strachey, 1971 -- • ACM National Conference 1972 ja gotot

16. LISP 60-luvulla • LISPin kehitys hajosi monelle taholle • Matemaattinen eleganssi kävi ilmeiseksi: LISPistä poistettiin imperatiivisia rakenteita • Kontrollirakenteena rekursio • Kaikki data ja koodi samanmuotoista (listoja)

17. ;; Palauta listan l viimeinen alkio (defun (rac l) (cond ((eq l ()) ()) ((eq (cdr l) ()) (car l)) (rac (cdr l)))) LISP-esimerkki

18. Simula 67: oliot • Kristen Nygaard & Ole-Johan Dahl: ohjelmointikieli simulaatioihin • Ensimmäinen versio vain simulaatioihin, jonot perusrakenteena • Simula 67: ALGOL 60:n yleiskäyttöinen luokkalaajennus • Luokat, oliot, virtuaalifunktiot, perintä

19. 70-luku: modulaarisuus • Ohjelmistot kasvoivat edelleen • Moduulit tulivat muotiin vasta 70-luvulla, vaikka toteutuksen kätkeminen oli keksitty jo paljon aiemmin • Uusia kieliä: Pascal, C, Modula

20. Smalltalk 1970-1980 • Xeroc PARC: kannettava “Dynabook” maallikoille, erityisesti lapsille • Tarvittiin yleistajuinen ohjelmointikieli järjestelmän laajentamiseen • Viestinvälitys ja periytyminen • 100% puhdas oliokieli: kaikki toiminnot palautuvat olioihin

21. | s f | s := Prompter prompt: ‘Enter line’ default: ‘’. f := bag new. s do [:c | c isLetter ifTrue: [f add: c asLowerCase]]. ^f Smalltalk-esimerkki

22. Smalltalk... • Paljon kiinnostusta, vähän menestystä • Edesauttoi myöhemmin uusien oliokielien syntyä

23. 70-luvun jälkeen • Oliot herättivät suurta kiinnostusta, tutkittiin proverbiaalisena “hopealuotina” • Olioiden integrointi imperatiivisiin kieliin: C++, CLOS • Olio-ohjelmointi on muodissa, mutta ei puhtaassa muodossaan

24. Funktiokielet tänään • Uusia funktionaalisia kieliä: ML, Haskell, Miranda, Gofer... • Teoreettiset ansiot käytännöllisiä suuremmat • Ei juuri menestystä kaupallisessa maailmassa... • ...mutta tutkimus, GNU-projekti?

25. Viimeinen alkio LISPillä • ;; Palauta listan l viimeinen alkio • (defun (rac l) • (cond ((eq l ()) ()) • ((eq (cdr l) ()) (car l)) • (rac (cdr l))))

26. ...ja sama ML:ksi: • fun rac (nil) = nil • | rac (a::x) = if null(x) then a • else rac(x)

27. “APL is like a beautiful diamond - flawless, beautifully symmetrical. But you can’t add anything to it. If you try to glue on another diamond, you don’t get a bigger diamond. LISP is like a ball of mud. Add more and it’s still a ball of mud - it still looks like LISP.” -- Joel Moses --