Programmeerparadigma’s Academiejaar 2006-2007 D. Janssens

1. Inleiding: de 4 belangrijkste paradigma’s Paradigma’s = soorten van programmeertaal. Het gaat hier telkens om “hogere” programmeertalen Niet chronologisch! Er zijn er veel meer, meestal voor gespecializeerd gebruik: bv. voor databases (SQL), tekstverwerking (TEX, postscript), scripting, … Imperatief programmeren Object-georiënteerd programmeren Functioneel programmeren Logisch programmeren abstractie van machinedetails bedoeld om programmeren gemakkelijker te maken uitvoerbaar via compilatie of interpretatie

A. Imperatieve talen Deze sluiten het nauwst aan bij de Von Neumann architectuur (J. Von Neumann 1945, K. Züse 1936) Zie RAM-RASP, Register machine, Algoritmen en Complexiteit

Imperatief programmeren: basisnoties Geheugen = rij adresseerbare geheugenplaatsen, bevat programma en data Toestand: functie die plaatsen (namen) afbeeldt op hun inhoud Fundamentele instructie : assignment (x := e) betekenis: bereken waarde van expressie e in de huidige toestand, en plaats de bekomen waarde in de geheugenplaats met naam x. Control flow instructies laten toe de volgorde waarin de instructies uitgevoerd worden te controleren (If B then S else R fi) Uitvoering van een programma = rij opeenvolgende toestandsveranderingen

Imperatieve talen: features Datatypes Control-flow enkelvoudige (char, bool, integer, real, …) samengestelde (array, record/struct, …) dynamisch gealloceerd geheugen type-checking subroutines, parameters extra control-flow instructies exceptions

Typering Aan de objecten gemanipuleerd door een programma (expressies, namen) wordt een type toegekend dat bepaalt voordelen: hoeveel geheugen er nodig is hoe de inhoud van het overeenkomstige stuk geheugen dient geïnterpreteerd te worden (bv real array of 3 dimensions, row-major) Hulpmiddel voor de programmeur Hulpmiddel voor de compiler ontwerper Bevordert sterk de detectie van vermoedelijke fouten(fout assignment, fout type van parameters, etc) In talen met een sterk typesysteem (bv functionele talen) is een type-correct programma verrassend vaak fout-vrij

Imperatieve talen: voor- en nadelen Voordelen: Sluit dicht aan bij machinearchitectuur Goed uitgewerkte theorie: eindige automaten (compilers), turing machines (complexiteitstheorie), algorithmiek, … Veruit het meest gebruikt Nadelen: Dwingt de programmeur te denken in termen van toestanden en toestandsovergangen, wat vaak niet goed aansluit bij het probleemdomein Leidt al te vaak tot onoverzichtelijke programma’s (GOTO)

Imperatieve (en OO) talen Cobol Fortran Algol 60 Algol 68 CPL Simula Pascal BCPL C Modula 2 Smalltalk C++ ADA Java

B. Object-georiënteerde talen Uitbreiding van het imperatieve paradigma, 3 principes: abstractie - inheritance - dynamische binding Object: geheel van data (attributen) die slechts met behulp van welbepaalde methoden kunnen gemanipuleerd worden (encapsulatie) Klasse: soort (type) van objecten, met zelfde attributen en methoden Een OO programma is in essentie een verzameling klassen (klassedefinities) evt uit libraries. Klassedefinities kunnen uitgebreid worden door gebruik te maken van inheritance: uit een meer algemene klasse een meer gespecialiseerde klasse maken door er bv methodes of attributen aan toe te voegen (re-use)

Inheritance Vorm Vierkant Cirkel Method overriding (area) positie area zijde area positie straal area Method overriding (area)

Dynamische binding Var x: vorm … x := v (vierkant) opp := x.area x := c (cirkel) x.area verwijst naar 2 verschillende methodes

Smalltalk (-80) In de taal Smalltalk werd de OO filosofie het verst doorgevoerd. Uitvoering = herhaal: Stuur een message naar een object ob om een van de methoden van ob op te roepen. Als reactie stuurt ob een object terug X  5+4 : stuur message “+” met als argumenten de objecten 4 en 5 naar het object x

Smalltalk Geïntegreerde programmeeromgeving, windows, muis class name Polygon superclass Object instance variable names ourPen numSides sideLength new ^ super new getpen getPen ourpen  Pen new defaultnib:2 draw numSides timesrepeat: [ourPen go: sideLength; turn: 360 // numSides] … Geïntegreerde programmeeromgeving, windows, muis

C - Java ++ De method bodies zijn in essentie imperatieve programma’s class sphereClass { public: sphereClass(double R): sphereClass(); … double Radius(); void SetRadius(double R); } class ballClass: public sphereClass private: char TheName[MAX_STRING+1]; }; De method bodies zijn in essentie imperatieve programma’s

OO paradigma: trends OO analyse: beschrijving van het domein in termen van objecten OO modellen - Unified Modeling Language Model transformatie: van abstract, platform-onafhankelijk naar concreet, platform-specifiek (Model-Driven Engineering) Aspecten, voor crosscutting concerns

C. Functionele talen basisidee: programmeren = functies bouwen Het uitrekenen van expressies gebeurt door substitutie een programma definieert een functie (input  output) samenstellen van complexer functies uit eenvoudiger delen: opbouwen van functionele termen eenvoudige datastructuren: lijsten (2 + 3) * (23 - 17)  5 * (23 - 17)  5 * 6  30 Niet meer verder te “reduceren”: normaalvorm

Functionele talen: kenmerken De taal levert een mechanisme om functies te definiëren (op te bouwen uit eenvoudiger functies) Functies zijn first class objecten: ze kunnen bv optreden als parameters van andere functies (= hogere orde functies) Interactie met systeem: dialoog. Geef functiedefinitie(s) en een expressie, het systeem evalueert die expressie. Uitgebreid typesysteem: elke expressie - en dus ook elke gebruikte functie - is getypeerd

Andere issues: Belangrijkste datastructuur: lijsten. Een aantal functies zijn voor- gedefinieerd. Referential transparency: namen, expressies hebben gedurende de hele uitvoering, en overal in het programma (de term) dezelfde betekenis. Er is geen assignment. Er is wel een beperkt gebruik van lokale namen. Anonieme en hogere orde functies Head [2,3,7,5]  2 Tail [2,3,7,5]  [3,7,5] (x.x+3) is de functie x  x+3. (y.(x.x+y)) is de functie die y afbeeldt op de functie x  x+y.

 - calculus en LISP  - Calculus is een formeel model voor berekenbaarheid, equivalent met Turing machines, gebaseerd op functies en substitutie (A. Church, 1941). LISP (List Processing language - later Common LISP) werd rond 1959 ingevoerd (J. McCarthy), en werd snel populair in de AI (vòòr Prolog). Een lijst ( A B C ) heeft 2 interpretaties: - letterlijk (met quote) - A toegepast op argumenten B en C Head en Tail heten traditioneel CAR en CDR in LISP Lijsten kunnen als element opnieuw lijsten bevatten; op die manier kan men complexe lijststructuren bouwen. ( + 5 7 8 ) geeft 20 QUOTE ( + 5 7 8 ) of `( + 5 7 8) geeft ( + 5 7 8 )

 - calculus: voorbeelden x.x (de identiteitsfunctie) fun.arg.(fun arg) (apply) x.y.y (select tweede argument, false) y.(x.(y (x x)) x.(y (x x))) (Y combinator)

LISP ( DEFINE ( equal lis1 lis2) (COND ( ( NOT (LIST? lis1 ) ) ( EQ? Lis1 lis2 ) ) ( ( NOT (LIST? lis2 ) ) ` ( ) ) ( ( NULL? lis1 ) ( NULL? lis2 ) ) ( ( NULL? lis2 ) ` ( ) ) ( ( equal (CAR lis1 ) (CAR lis2 ) ) ( equal ( CDR lis1 ) (CDR lis2 ) ) ) ( ELSE ‘ ( ) ) ) ) Functie voor gelijkheid van lijsten zonder sublijsten. ELSE staat voor #T (true). False wordt voorgesteld als de lege lijst ( )

Haskell: som total = 0; for (i = 1; i  10; ++i) total = total+i; Som van de integers 1 tot 10 in Java: total = 0; for (i = 1; i  10; ++i) total = total+i; Basisidee is daar dus assignment aan variabelen. In Haskell wordt dat: sum [1..10] met sum gedefinieerd door: sum[ ] = 0 sum[x:xs] = x + sum[xs] 22

Haskell: quicksort f [] = [] f (x:xs) = f ys ++ [x] ++ f zs where ys = [a | a  xs, a  x] zs = [b | b  xs, b > x] 23

Functionele talen LISP Common LISP ML SASL Scheme Standard ML Miranda Haskell Gofer

D. Logisch programmeren A. Colmerauer, Ph. Roussel, R. Kowalski (1975, 1981) Basisidee: interactie = dialoog waarin - de gebruiker feiten, regels en een query geeft - het systeem de query beantwoordt op basis van de feiten en regels. Het systeem probeert de query te bewijzen. “Niet bewijsbaar” wordt gelijkgesteld met”neen”. de regels zijn logische afleidingsregels, gebaseerd op predicaten- calculus belangrijkste taal: Prolog

Prolog: clauses Atomaire predicaten : Functor + parameters Clausale vorm : Horn clauses: m = 0 of m = 1 Man(Fred) Dochter(An, Karl) B1 v B2 v … v Bm  A1 ^ A2 ^ A3 ^ … ^ An

Resolutie Als gegeven is: A1 , A2 , B1  A1 en B3  B1 ^ A2 , dan kan men, om B3 te bewijzen, als volgt tewerk gaan: - gebruik regel B3  B1 ^ A2 om te besluiten dat het volstaat B1 en A2 te bewijzen. - gebruik regel B1  A1 om te besluiten dat het volstaat A1 en A2 te bewijzen. - stel vast dat A1 en A2 gegeven zijn. In het algemeen heeft men dus telkens een aantal nog te bewijzen termen: die noemt men goals.

Prolog: variabelen Er mogen ook variabelen voorkomen: ouder(X,Y) :- moeder(X,Y) betekent: X,Y: ouder(X,Y)  moeder(X,Y) Het prolog systeem gaat de variabelen instantieren (vervangen door meer concrete termen): Het resolutieproces beslist dat X vervangen (geinstantieerd) moet worden door Bob Vader(Bob). (feit) Man(X) :- vader(X).

Unificatie In het algemeen moet men twee termen (hier Bob en X) proberen “gelijk te maken” door variabelen te vervangen door meer specifieke termen. Dit zal ook gebeuren in het pattern matching proces van het functioneel programmeren. A(b,X) A(Y,c) X = c Y = b A(b,c)

Prolog append ( [ ] , List , List ) . append ( [ Head | List_1 ] , List_2 , [ Head | List_3 ] ) :- append ( List_1 , List_2, List_3 ) . [ A | B ] is de lijst met A als head en B als tail. A is hier dus een lijstelement, B is zelf een lijst De query ? append ( [ a,b ] , [ c,d ] , X ) wordt als volgt opgelost. stap 1: instantiatie: Head = a List_1 = [ b ] List_2 = [ c,d ] X = [ Head | List_3 ] goal: append ( [ b ] , [ c,d ] , List_3 )

Prolog stap 2: instantiatie: Head' = b List'_1 = [ ] List'_2 = [ c,d ] List_3 = [ Head' | List'_3 ] goal: append ( [ ] , [ c,d ] , List'_3 ) stap 3: instantiatie: List = [ c,d ] List'_3 = [ c,d ] goal: nihil na substitutie: X = [ a | [ b | [ c,d ] ] ] = [ a,b,c,d ]

Deel 1: Functionele talen - Haskell Fundamenten: -calculus en recursieve functies LISP en Common LISP - Haskell (naar Haskell B. Curry) Evaluatiestrategieën, eager en lazy Combinatorische logica Monaden Compilatie van functionele talen, continuaties Features van Haskell