Gliederung

Gliederung
n Teil I: Einleitung und Grundbegriffe
l 1. Organisatorisches
l 2. Grundlagen von Programmiersprachen
n Teil II: Imperative und objektorientierte Programmierung
l
l
l
l
1. Grundelemente der Programmierung
2. Objekte, Klassen und Methoden
3. Rekursion und dynamische Datenstrukturen
4. Erweiterung von Klassen und fortgeschrittene Konzepte
n Teil III: Funktionale Programmierung: Haskell
n Teil IV: Logische Programmierung: Prolog
III.1 Prinzipien der funktionalen Programmierung- 1 -
Populäre Programmiersprachen
Quelle: www.tiobe.com, Oct. 2015
III.1 Prinzipien der funktionalen Programmierung- 2 -
Populäre Programmiersprachen
1. Java
....
32. Prolog
...
39. Haskell
Quelle: www.tiobe.com, Jan. 2016
III.1 Prinzipien der funktionalen Programmierung- 3 -
Kenntnis verschiedener Sprachen
n Eigene Ideen bei der Software-Entwicklung
können besser ausgedrückt werden
n Nötig, um in konkreten Projekten geeignete
Sprache auszuwählen
n Erleichtert das Erlernen weiterer
Programmiersprachen
n Nötig für den Entwurf neuer
Programmiersprachen
III.1 Prinzipien der funktionalen Programmierung- 4 -
Übersicht
Imperative Sprachen
l Folge von nacheinander
ausgeführten Anweisungen
n Prozedurale Sprachen
l Variablen, Zuweisungen,
Kontrollstrukturen
n Objektorientierte Sprachen
l Objekte und Klassen
l Abstrakte Datentypen und
Vererbung
Deklarative Sprachen
l Spezifikation dessen, was
berechnet werden soll
l Compiler legt fest, wie
Berechnung verläuft
n Funktionale Sprachen
l keine Seiteneffekte
l Rekursion
n Logische Sprachen
l Regeln zur Definition von
Relationen
III.1 Prinzipien der funktionalen Programmierung- 5 -
Wichtige Programmiersprachen
1950
Fortran
1960
Cobol
Algol 60
PL/1
1970
Lisp
Simula
Algol 68
Pascal
Smalltalk
C
1980
Scheme
Prolog
ML
Ada
C++
Eiffel
Modula-3
1990
Ada-95
Miranda
Java
2000
Python
Haskell
Scala
prozedural
objektorientiert
funktional
logisch
I.2. Grundlagen von Programmiersprachen - 6 -
n 1. Prinzipien der funktionalen Programmierung
n 2. Deklarationen
n 3. Ausdrücke
n 4. Muster (Patterns)
n 5. Typen und Datenstrukturen
n 6. Funktionale Programmiertechniken
I.2. Grundlagen von Programmiersprachen - 7 -
Imperative Programmierung (Java)
Eingabe: Eine Liste x
Ausgabe: Länge der Liste x
Algorithmus:
class Element
Vergleichbar wert;
Element next; ...
1. Setze n = 0.
public class Liste
{
Element kopf;
...
static int len (Liste x) {
int n = 0;
while (x.kopf != null) {
x.kopf = x.kopf.next;
n = n + 1;
}
2. Falls x nicht die
leere Liste ist, dann:
2a. Lösche das erste
Element von x.
2b. Erhöhe n um 1.
2c. Gehe zu Schritt 2.
3. Liefere n zurück.
{
}
return n;
}
III.1 Prinzipien der funktionalen Programmierung- 8 -
Kennzeichen imperativer Programmierung
n Programm besteht aus einzelnen Anweisungen,
die nacheinander abgearbeitet werden.
n Verschiedene Kontrollstrukturen, um
Programmablauf zu steuern.
n Abarbeitung einer Anweisung ändert Werte der
Variablen.
n Seiteneffekte
n Programmierer muss Speicherorganisation
bedenken
III.1 Prinzipien der funktionalen Programmierung- 9 -
Funktionale Programmierung (Haskell)
A.
Falls die Liste x leer ist, so ist len(x) = 0.
B.
Falls die Liste x nicht leer ist und
"rest" die Liste x ohne ihr erstes Element ist,
so ist len(x) = 1 + len(rest).
Programm in Haskell:
len []
=
0
len (kopf : rest)
=
1 + len rest
III.1 Prinzipien der funktionalen Programmierung- 10 -
Ausführung funktionaler Programme
len []
=
0
len (kopf : rest)
=
1 + len rest
len [15, 70, 36]
=
1 + len [70, 36]
=
1 + 1 + len [36]
=
1 + 1 + 1 + len []
=
1 + 1 + 1 + 0
=
3
III.1 Prinzipien der funktionalen Programmierung- 11 -
Kennzeichen funktionaler Programme
n Rekursion statt Schleifen
n Keine Seiteneffekte (referentielle Transparenz)
n Funktionen als gleichberechtigte Datenobjekte
(Funktionen höherer Ordnung)
n Verwendung von einer Funktions-Implementierung für verschiedene Typen (Polymorphismus)
n Programme sind kürzer, klarer, besser zu warten,
zuverlässiger, schneller zu erstellen
III.1 Prinzipien der funktionalen Programmierung- 12 -
Seiteneffekte
n Seiteneffekt: Veränderung des (Speicher-)Zustands
n Fehlende Seiteffekte in Funktionalen
Programmiersprachen:
l Verzicht auf Variablen und Wertzuweisungen
l Ausschließlich Verwendung von Ausdrücken
n Referenzielle Transparenz:
l Wert eines Ausdrucks hängt nicht vom Zeitpunkt oder der Reihenfolge
der Auswertung ab.
III.1 Prinzipien der funktionalen Programmierung- 13 -
Funktionale Programmierung (Haskell)
n Interaktiver Modus des Glasgow Haskell
Compilers (GHCi)
l Eingabe: Auszuwertender Ausdruck
l Ausgabe: Ergebnis des ausgewerteten Ausdrucks
n Bsp:
l Eingabe: len [15, 36, 70]
l Ausgabe: 3
n Interpreter
l führen jede Zeile des Programms nacheinander aus.
l Vorteil: Keine vorherige Übersetzung nötig, gut zur
Programmentwicklung geeignet.
l Nachteil: Ineffizienter als Compiler.
III.1 Prinzipien der funktionalen Programmierung- 14 -
n 1. Prinzipien der funktionalen Programmierung
n 2. Deklarationen
n 3. Ausdrücke
n 4. Muster (Patterns)
n 5. Typen und Datenstrukturen
n 6. Funktionale Programmiertechniken
III.1 Prinzipien der funktionalen Programmierung- 15 -
Deklarationen
len :: [Int] -> Int
len []
len (kopf : rest)
=
=
0
1 + len rest
square :: Int -> Int
square x = x * x
Typdeklarationen
Programm in Haskell:
Funktionsdeklarationen
Folge von linksbündig untereinander stehenden Deklarationen
III.1 Prinzipien der funktionalen Programmierung- 16 -
Deklarationen
len :: [Int] -> Int
len []
len (kopf : rest)
=
=
0
1 + len rest
::
type
square :: Int -> Int
square x = x * x
var
,
decl
var
pat
=
exp
III.1 Prinzipien der funktionalen Programmierung- 17 -
Auswertungsstrategie
square :: Int -> Int
square x = x * x
square (12 - 1)
square 11
(12 - 1) * (12 - 1)
11 * (12 - 1)
(12 - 1) * 11
11 * 11
121
strikte Auswertung (call-by-value), innen links
nicht-strikte Auswertg. (call-by-name), außen links
III.1 Prinzipien der funktionalen Programmierung- 18 -
Bedingte definierende Gleichungen
maxi :: (Int, Int) -> Int
maxi (x, y)
| x >= y
= x
| otherwise
var
= y
type
::
,
decl
var
pat
|
exp
=
exp
=
exp
III.1 Prinzipien der funktionalen Programmierung- 19 -
Currying
plus :: (Int, Int) -> Int
plus (x, y) = x + y
Currying
plus :: Int -> Int -> Int
plus x y = x + y
var
type
::
,
decl
var
pat
|
exp
=
exp
=
exp
III.1 Prinzipien der funktionalen Programmierung- 20 -
Pattern Matching
und :: Bool -> Bool -> Bool
und True y= y
und False y
= False
x
var
type
::
,
decl
var
pat
|
exp
=
exp
=
exp
III.1 Prinzipien der funktionalen Programmierung- 21 -
Pattern Matching
und :: Bool -> Bool -> Bool
und True y= y
und
y
= False
x
len :: [Int] -> Int
len []
= 0
len (x : xs)
= 1 + len xs
Bool = "True" | "False"
Liste = "[]" |
Element ":" Liste
III.1 Prinzipien der funktionalen Programmierung- 22 -
Lokale Deklarationen
roots :: Float -> Float -> Float -> (Float, Float)
roots a b c = ((-b - d)/e, (-b + d)/e)
where {d = sqrt (b*b - 4*a*c);
e = 2*a}
where
d = sqrt b*b - 4*a*c
e = 2*a
locdecls
{
var
decl
::
,
;
type
}
decl
var
pat
|
exp
=
exp
=
exp
where locdecls
III.1 Prinzipien der funktionalen Programmierung- 23 -